shark-on-lambda 1.0.0.rc4 → 2.0.0.rc3

data/lib/shark_on_lambda/api_gateway_handler.rb

@@ -1,61 +1,9 @@
 # frozen_string_literal: true
 
 module SharkOnLambda
-  class ApiGatewayHandler
-    class << self
-      attr_writer :controller_class_name
-
-      def controller_action?(action)
-        controller_actions.include?(action.to_sym)
-      end
-
-      def controller_class_name
-        return @controller_class_name if defined?(@controller_class_name)
-
-        name_inferrer = Inferrers::NameInferrer.from_handler_name(name)
-        @controller_class_name = name_inferrer.controller
-      end
-
-      private
-
-      def controller_actions
-        return [] if controller_class.nil?
-
-        controller_class.public_instance_methods(false)
-      end
-
-      def controller_class
-        controller_class_name.safe_constantize
-      end
-
-      def method_missing(action, *args, &_block)
-        return super unless respond_to_missing?(action)
-
-        new.call(action, *args)
-      end
-
-      def respond_to_missing?(name, _include_all = false)
-        controller_action?(name)
-      end
-    end
-
-    attr_reader :application, :env
-    delegate :context, :event, to: :adapter
-
-    def initialize
-      @application = Application.new
-    end
-
-    def call(action, event:, context:)
-      raise NoMethodError unless self.class.controller_action?(action)
-
-      adapter = RackAdapters::ApiGateway.new(context: context, event: event)
-      env = adapter.env
-      env['shark.controller'] = self.class.controller_class_name
-      env['shark.action'] = action.to_s
-
-      status, headers, body = @application.call(env)
-      adapter.build_response(status, headers, body)
+  class ApiGatewayHandler < RackOnLambda::Handlers::RestApi
+    def self.call(event:, context:)
+      super(event: event, context: context, app: SharkOnLambda.application)
     end
   end
 end

data/lib/shark_on_lambda/application.rb

@@ -2,16 +2,86 @@
 
 module SharkOnLambda
   class Application
+    attr_reader :routes
+
+    delegate :middleware, :root, to: :config
+
+    class << self
+      def config
+        @config ||= Configuration.new
+      end
+
+      def inherited(subclass)
+        super
+
+        SharkOnLambda.application = subclass.new
+      end
+    end
+
+    def initialize
+      register_jsonapi_rendering
+      initialize_router
+    end
+
     def call(env)
-      dup.send('_call', env)
+      dup.call!(env)
+    end
+
+    def call!(env)
+      middleware_stack = middleware.build(routes)
+      middleware_stack.call(env)
+    end
+
+    def config
+      self.class.config
+    end
+
+    def config_for(name, env: SharkOnLambda.env)
+      config = load_config_file(name, env: env, fail_with_exception: true)
+      config.deep_merge(load_config_file("#{name}.local", env: env))
+    end
+
+    def initialize!
+      load_routes
+      run_initializers
     end
 
     private
 
-    def _call(env)
-      dispatcher = SharkOnLambda.config.dispatcher
-      middleware_stack = SharkOnLambda.config.middleware.build(dispatcher)
-      middleware_stack.call(env)
+    def initialize_router
+      router_config = ActionDispatch::Routing::RouteSet::Config.new(nil, true)
+      @routes = ActionDispatch::Routing::RouteSet.new_with_config(router_config)
+    end
+
+    def load_config_file(name, env:, fail_with_exception: false)
+      filename = "#{name}.yml"
+      config_file = SharkOnLambda.root.join('config', filename)
+      unless config_file.exist?
+        return {} unless fail_with_exception
+
+        raise ArgumentError,
+              "Could not load configuration. No such file - #{config_file}"
+      end
+
+      erb_parsed_config = ERB.new(config_file.read).result
+      config = YAML.safe_load(erb_parsed_config, [], [], true, filename) || {}
+      config.fetch(env, {}).with_indifferent_access
+    end
+
+    def load_routes
+      routes_path = SharkOnLambda.root.join('config', 'routes.rb').to_s
+      load routes_path if File.exist?(routes_path)
+    end
+
+    def register_jsonapi_rendering
+      ::Mime::Type.register('application/vnd.api+json', :jsonapi)
+      ::ActionDispatch::Request.parameter_parsers[:jsonapi] =
+        ::ActionDispatch::Request.parameter_parsers[:json].dup
+    end
+
+    def run_initializers
+      initializers_folder = SharkOnLambda.root.join('config', 'initializers')
+      Dir.glob(initializers_folder.join('*.rb')).each { |path| load path }
     end
   end
 end

data/lib/shark_on_lambda/base_controller.rb

@@ -6,13 +6,6 @@ module SharkOnLambda
       AbstractController::Translation,
       AbstractController::AssetPaths,
 
-      ActionController::UrlFor,
-      ActionController::ConditionalGet,
-      ActionController::EtagWithTemplateDigest,
-      ActionController::EtagWithFlash,
-      ActionController::Caching,
-      ActionController::MimeResponds,
-      ActionController::ImplicitRender,
       ActionController::Cookies,
       ActionController::Flash,
       ActionController::FormBuilder,
@@ -24,10 +17,27 @@ module SharkOnLambda
       ActionController::HttpAuthentication::Token::ControllerMethods,
       ActionView::Layouts
     ].freeze
-    ActionController::Base.without_modules(EXCLUDED_MODULES).each do |mod|
+    ActionController::API.without_modules(EXCLUDED_MODULES).each do |mod|
       include mod
     end
 
+    ActionController::Renderers.add :jsonapi do |object, options|
+      response.set_header('content-type', 'application/vnd.api+json')
+      return { data: {} }.to_json if object.nil?
+
+      jsonapi_renderer = JsonapiRenderer.new(object)
+
+      jsonapi_params = params.slice(:fields, :include)
+      jsonapi_params.permit!
+      jsonapi_params = JsonapiParameters.new(jsonapi_params.to_h)
+
+      render_options = jsonapi_params.to_h.deep_merge(options)
+      jsonapi_object = jsonapi_renderer.render(render_options)
+
+      response.status = jsonapi_renderer.status
+      jsonapi_object.to_json
+    end
+
     def self.dispatch(*)
       super
     rescue AbstractController::ActionNotFound,
@@ -38,7 +48,17 @@ module SharkOnLambda
 
     def redirect_to(*)
       super
-      self.response_body = '' if no_body?
+
+      self.response_body = no_body? ? nil : { data: {} }.to_json
+    end
+
+    def render(object, options = {})
+      options.merge!(
+        jsonapi: object,
+        content_type: 'application/vnd.api+json'
+      )
+
+      super(options)
     end
 
     private

data/lib/shark_on_lambda/cacheable.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module SharkOnLambda
+  module Cacheable
+    delegate :cache, :global_cache, to: SharkOnLambda
+
+    def cache_duration(item)
+      cache_durations[item] || cache_durations[:default]
+    end
+
+    private
+
+    def cache_durations
+      return @cache_durations if defined?(@cache_durations)
+
+      settings = SharkOnLambda.application.config_for(:settings) || {}
+      @cache_durations = settings.fetch(:cache_durations, {})
+      @cache_durations = @cache_durations.with_indifferent_access
+    end
+  end
+end

data/lib/shark_on_lambda/configuration.rb

@@ -2,63 +2,7 @@
 
 module SharkOnLambda
   class Configuration < OpenStruct
-    include Concerns::ResettableSingleton
-
-    attr_writer :dispatcher, :stage
-
-    class << self
-      include Concerns::YamlConfigLoader
-
-      attr_writer :database_files, :settings_files
-
-      def database_files
-        return @database_files if defined?(@database_files)
-
-        files = %w[config/database.yml config/database.local.yml]
-        @database_files = paths(files)
-      end
-
-      def load(stage, fallback: :default)
-        load_settings(stage, fallback: fallback)
-        load_database_configuration(stage, fallback: fallback)
-
-        instance
-      end
-
-      def settings_files
-        return @settings_files if defined?(@settings_files)
-
-        files = %w[config/settings.yml config/settings.local.yml]
-        @settings_files = paths(files)
-      end
-
-      protected
-
-      def load_database_configuration(stage, fallback:)
-        instance.database = load_yaml_files(stage: stage,
-                                            fallback: fallback,
-                                            paths: paths(database_files))
-      end
-
-      def load_settings(stage, fallback:)
-        settings = load_yaml_files(stage: stage,
-                                   fallback: fallback,
-                                   paths: paths(settings_files))
-        settings.each_pair do |key, value|
-          next if key.to_s == 'serverless'
-
-          instance.send("#{key}=", value)
-        end
-      end
-
-      def paths(files)
-        files.map { |file| SharkOnLambda.config.root.join(file) }
-      end
-    end
-
-    def dispatcher
-      @dispatcher ||= Dispatcher.new
-    end
+    attr_reader :root
 
     def middleware
       @middleware ||= ActionDispatch::MiddlewareStack.new do |middleware_stack|
@@ -66,16 +10,8 @@ module SharkOnLambda
       end
     end
 
-    def root
-      @root ||= Pathname.new('.')
-    end
-
     def root=(new_root)
       @root = Pathname.new(new_root)
     end
-
-    def stage
-      @stage || 'development'
-    end
   end
 end

data/lib/shark_on_lambda/inferrers/serializer_inferrer.rb

@@ -31,14 +31,17 @@ module SharkOnLambda
       def serializer_class_names
         return @serializer_class_names if defined?(@serializer_class_names)
 
-        @serializer_class_names = object_class.ancestors.map do |ancestor|
-          ancestor_name = ancestor.name
-          next if ancestor_name.blank?
+        @serializer_class_names =
+          object_class.ancestors.reduce([]) do |result, ancestor|
+            ancestor_name = ancestor.name
+            next result if ancestor_name.blank?
 
-          name_inferrer = NameInferrer.from_model_name(ancestor_name)
-          name_inferrer.serializer
-        end
-        @serializer_class_names.compact! || @serializer_class_names
+            result << serializer_name_from_model_name(ancestor_name)
+          end
+      end
+
+      def serializer_name_from_model_name(model_name)
+        "#{model_name.underscore}_serializer".camelize
       end
     end
   end

data/lib/shark_on_lambda/jsonapi_renderer.rb

@@ -2,21 +2,27 @@
 
 module SharkOnLambda
   class JsonapiRenderer
-    def initialize(renderer: nil)
+    attr_reader :object, :status
+
+    def initialize(object, renderer: nil)
+      @object = object
       @renderer = renderer || JSONAPI::Serializable::Renderer.new
+
+      @status = 200
     end
 
-    def render(object, options = {})
-      object = transform_active_model_errors(object)
+    def render(options = {})
+      @status = options[:status] if options[:status]
+      object_to_render = transform_active_model_errors(object)
 
-      unless renderable?(object, options)
-        return handle_unrenderable_objects(object, options)
+      unless renderable?(object_to_render, options)
+        return handle_unrenderable_objects(object_to_render, options)
       end
 
-      if error?(object)
-        render_errors(object, options).to_json
+      if error?(object_to_render)
+        render_errors(object_to_render, options)
       else
-        render_success(object, options).to_json
+        render_success(object_to_render, options)
       end
     end
 
@@ -54,6 +60,7 @@ module SharkOnLambda
         Errors[500].new("Could not find serializer for: #{item.name}.")
       end
 
+      @status = 500
       render_errors(errors, options)
     end
 
@@ -93,7 +100,7 @@ module SharkOnLambda
     def transform_active_model_errors(errors)
       return errors unless active_model_error?(errors)
 
-      result = errors.messages.map do |attribute, attribute_errors|
+      errors.messages.flat_map do |attribute, attribute_errors|
         attribute_errors.map do |attribute_error|
           error_message = "`#{attribute_name(attribute)}' #{attribute_error}"
           Errors[422].new(error_message).tap do |error|
@@ -101,7 +108,6 @@ module SharkOnLambda
           end
         end
       end
-      result.flatten! || result
     end
 
     def unrenderable_objects(object, options)

data/lib/shark_on_lambda/middleware/base.rb

@@ -10,12 +10,10 @@ module SharkOnLambda
       end
 
       def call(env)
-        dup.send('_call', env)
+        dup.call!(env)
       end
 
-      private
-
-      def _call(_env)
+      def call!(_env)
         raise NotImplementedError
       end
     end

data/lib/shark_on_lambda/middleware/honeybadger.rb

@@ -11,24 +11,29 @@ module SharkOnLambda
         @tags = tags
       end
 
-      private
-
-      def _call(env)
-        @env = env
+      def call!(env)
         app.call(env)
       rescue StandardError => e
-        notify(e) unless shark_error?(e)
+        notify(e, env) unless shark_error?(e) && client_error?(e)
 
         raise e
       end
 
-      def notify(error)
+      private
+
+      def client_error?(error)
+        error.respond_to?(:status) && error.status < 500
+      end
+
+      def notify(error, env)
+        params = env.fetch('action_dispatch.request.parameters', {})
+
         ::Honeybadger.notify(
           error,
           tags: tags,
-          controller: @env['shark.controller'],
-          action: @env['shark.action'],
-          parameters: @env['action_dispatch.request.parameters']
+          controller: params[:controller],
+          action: params[:action],
+          parameters: params
         )
       end