shark-on-lambda 0.0.0 → 0.6.7

data/lib/shark_on_lambda.rb

@@ -1 +1,104 @@
-require 'shark-on-lambda'
+# frozen_string_literal: true
+
+require 'forwardable'
+require 'ostruct'
+require 'pathname'
+require 'singleton'
+
+require 'active_support/all'
+require 'jsonapi/deserializable'
+require 'jsonapi/serializable'
+require 'rack/utils'
+require 'yaml'
+
+require 'shark_on_lambda/version'
+
+require 'shark_on_lambda/concerns/filter_actions'
+require 'shark_on_lambda/concerns/resettable_singleton'
+require 'shark_on_lambda/concerns/yaml_config_loader'
+
+require 'shark_on_lambda/configuration'
+require 'shark_on_lambda/secrets'
+
+require 'shark_on_lambda/inferrers/name_inferrer'
+require 'shark_on_lambda/inferrers/serializer_inferrer'
+
+require 'shark_on_lambda/api_gateway/serializers/base_error_serializer'
+require 'shark_on_lambda/api_gateway/concerns/http_response_validation'
+require 'shark_on_lambda/api_gateway/base_controller'
+require 'shark_on_lambda/api_gateway/base_handler'
+require 'shark_on_lambda/api_gateway/errors'
+require 'shark_on_lambda/api_gateway/headers'
+require 'shark_on_lambda/api_gateway/jsonapi_controller'
+require 'shark_on_lambda/api_gateway/jsonapi_parameters'
+require 'shark_on_lambda/api_gateway/jsonapi_renderer'
+require 'shark_on_lambda/api_gateway/parameters'
+require 'shark_on_lambda/api_gateway/query'
+require 'shark_on_lambda/api_gateway/request'
+require 'shark_on_lambda/api_gateway/response'
+
+# Top-level module for this gem.
+module SharkOnLambda
+  class << self
+    extend ::Forwardable
+
+    attr_writer :logger
+
+    def_instance_delegators :config, :root, :stage
+
+    def config
+      Configuration.instance
+    end
+
+    def configure
+      yield(config, secrets)
+    end
+
+    def initialize!
+      yield(config, secrets)
+
+      Configuration.load(stage)
+      Secrets.load(stage)
+      run_initializers
+
+      true
+    end
+
+    def load_configuration
+      Configuration.load(stage)
+      Secrets.load(stage)
+
+      true
+    end
+
+    def logger
+      @logger ||= ::Logger.new(STDOUT)
+    end
+
+    def reset_configuration
+      known_stage = config.stage
+      known_root = config.root
+
+      Configuration.reset
+      Secrets.reset
+
+      config.root = known_root
+      config.stage = known_stage
+
+      true
+    end
+
+    def secrets
+      Secrets.instance
+    end
+
+    protected
+
+    def run_initializers
+      initializers_path = root.join('config', 'initializers')
+      Dir.glob(initializers_path.join('*.rb')).each do |path|
+        load path
+      end
+    end
+  end
+end

data/lib/shark_on_lambda/api_gateway/base_controller.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module SharkOnLambda
+  module ApiGateway
+    class BaseController
+      include SharkOnLambda::Concerns::FilterActions
+      include Concerns::HttpResponseValidation
+
+      attr_reader :action_name, :event, :context
+
+      def initialize(event:, context:)
+        @event = event
+        @context = context
+      end
+
+      def call(method)
+        @action_name = method.to_s
+        call_with_filter_actions(method)
+        response.to_h
+      end
+
+      def params
+        @params ||= Parameters.new(request)
+      end
+
+      def redirect_to(url, status: 307, message: nil)
+        status = status.to_i
+        validate_url!(url)
+        validate_redirection_status!(status)
+
+        uri = URI.parse(url)
+        response.set_header('Location', uri.to_s)
+        body = message.presence || "You are being redirected to: #{url}"
+
+        render(body, status: status)
+      end
+
+      def render(object, status: 200)
+        update_response(status: status, body: object)
+        respond!
+      end
+
+      def request
+        @request ||= Request.new(event: event, context: context)
+      end
+
+      def response
+        @response ||= Response.new
+      end
+
+      protected
+
+      def respond!
+        if responded?
+          raise Errors[500],
+                '#render or #redirect_to was called more than once.'
+        end
+
+        @responded = true
+        response
+      end
+
+      def responded?
+        @responded.present?
+      end
+
+      def update_response(status:, body: nil)
+        status = status.to_i
+        validate_response_status!(status)
+
+        response.status = status
+        response.body = body.to_s.presence
+      end
+    end
+  end
+end

data/lib/shark_on_lambda/api_gateway/base_handler.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+module SharkOnLambda
+  module ApiGateway
+    class BaseHandler
+      class << self
+        attr_writer :controller_class
+
+        def controller_class
+          return @controller_class if defined?(@controller_class)
+
+          name_inferrer = Inferrers::NameInferrer.from_handler_name(name)
+          controller_class_name = name_inferrer.controller
+          @controller_class = controller_class_name.safe_constantize
+        end
+
+        protected
+
+        def known_actions
+          controller_class.public_instance_methods(false)
+        end
+
+        def method_missing(name, *args, &block)
+          return super unless respond_to_missing?(name)
+
+          instance = new
+          instance.call(name, *args, &block)
+        end
+
+        def respond_to_missing?(name, _include_all = false)
+          known_actions.include?(name)
+        end
+      end
+
+      def call(action, event:, context:)
+        controller_class = self.class.controller_class
+        controller = controller_class.new(event: event, context: context)
+        controller.call(action)
+      rescue StandardError => e
+        handle_error(e)
+      end
+
+      protected
+
+      def client_error?(error)
+        error.is_a?(Errors::Base) && (400..499).cover?(error.status)
+      end
+
+      def error_body(status, message)
+        {
+          errors: [{
+            status: status.to_s,
+            title: ::Rack::Utils::HTTP_STATUS_CODES[status],
+            detail: message
+          }]
+        }.to_json
+      end
+
+      def error_response(error)
+        status = error.try(:status) || 500
+
+        {
+          statusCode: status,
+          headers: {
+            'Content-Type' => 'application/vnd.api+json'
+          },
+          body: error_body(status, error.message)
+        }
+      end
+
+      def handle_error(error)
+        unless client_error?(error)
+          SharkOnLambda.logger.error(error.message)
+          SharkOnLambda.logger.error(error.backtrace.join("\n"))
+          ::Honeybadger.notify(error) if defined?(::Honeybadger)
+        end
+
+        error_response(error)
+      end
+    end
+  end
+end

data/lib/shark_on_lambda/api_gateway/concerns/http_response_validation.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module SharkOnLambda
+  module ApiGateway
+    module Concerns
+      # Provides methods for HTTP-related validation, e. g. for status codes
+      # and URIs. If validation fails, question mark methods return *false*,
+      # exclamation mark methods raise an exception.
+      #
+      # TODO: Specs for this module.
+      module HttpResponseValidation
+        # Validates a URL.
+        #
+        # @param url [String] The URL to validate.
+        # @return [TrueClass] If the URL is valid and present.
+        # @return [FalseClass] If the URL is invalid or blank.
+        def valid_url?(url)
+          URI.parse(url.to_s)
+          url.present?
+        rescue URI::InvalidURIError
+          false
+        end
+
+        # Validates a HTTP redirection status code.
+        #
+        # @param status [Number] The HTTP status code to validate.
+        # @return [NilClass] Returns *nil* if *status* is valid.
+        # @raise [Errors::InternalServerError] If the status code does not
+        #                                      represent a HTTP redirection.
+        def validate_redirection_status!(status)
+          validate_response_status!(status)
+          return if (300..399).cover?(status)
+
+          raise Errors[500], 'HTTP redirections must have a 3xx status code.'
+        end
+
+        # Validates a HTTP status code.
+        #
+        # @param status [Number] The HTTP status code to validate.
+        # @return [NilClass] Returns *nil* if *status* is valid.
+        # @raise [Errors::InternalServerError] If the status code is unknown.
+        def validate_response_status!(status)
+          return if ::Rack::Utils::HTTP_STATUS_CODES[status].present?
+
+          raise Errors[500], 'Unknown response status code.'
+        end
+
+        # Validates a URL.
+        #
+        # @param url [String] The URL to validate.
+        # @return [NilClass] Returns *nil* if *url* is valid.
+        # @raise [Errors::InternalServerError] If the URL is invalid.
+        def validate_url!(url)
+          return if valid_url?(url)
+
+          raise Errors[500], "`#{url}' is not a valid URL."
+        end
+      end
+    end
+  end
+end

data/lib/shark_on_lambda/api_gateway/errors.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module SharkOnLambda
+  module ApiGateway
+    module Errors
+      class Base < ::StandardError
+        attr_accessor :id, :code, :meta, :pointer, :parameter
+        attr_writer :detail
+
+        def self.status(status_code)
+          define_method :status do
+            status_code
+          end
+        end
+
+        def detail
+          return @detail if @detail.present?
+          return nil if message == self.class.name
+
+          message
+        end
+
+        def title
+          ::Rack::Utils::HTTP_STATUS_CODES[status]
+        end
+      end
+
+      def self.[](status_code)
+        @errors[status_code]
+      end
+
+      @errors = ::Rack::Utils::HTTP_STATUS_CODES.map do |status_code, message|
+        next unless (400..599).cover?(status_code) && message.present?
+
+        error_class = Class.new(Base) do
+          status status_code
+        end
+        class_name_parts = message.to_s.split(/\s+/)
+        class_name_parts.map! { |word| word.gsub(/[^a-z]/i, '').capitalize }
+        class_name = class_name_parts.join('')
+        const_set(class_name, error_class)
+
+        [status_code, error_class]
+      end
+      @errors.compact!
+      @errors = @errors.to_h
+    end
+  end
+end

data/lib/shark_on_lambda/api_gateway/headers.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module SharkOnLambda
+  module ApiGateway
+    class Headers
+      def initialize
+        @headers = {}
+      end
+
+      def [](key)
+        @headers[normalized_key(key)]
+      end
+
+      def []=(key, value)
+        @headers[normalized_key(key)] = value.to_s
+      end
+
+      def delete(key)
+        @headers.delete(normalized_key(key))
+      end
+
+      def key?(key)
+        @headers.key?(normalized_key(key))
+      end
+
+      def to_h
+        @headers.dup
+      end
+
+      protected
+
+      def normalized_key(key)
+        key.to_s.downcase
+      end
+    end
+  end
+end

data/lib/shark_on_lambda/api_gateway/jsonapi_controller.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module SharkOnLambda
+  module ApiGateway
+    class JsonapiController < BaseController
+      # TODO: Evaluate if deserialisation should happen in here, happen
+      #       somewhere else in SharkOnLambda, or if it should be something
+      #       the user has to take care of entirely.
+      #
+      # class << self
+      #   attr_writer :deserializer_class
+      #
+      #   def deserializer_class
+      #     return @deserializer_class if defined?(@deserializer_class)
+      #
+      #     name_inferrer = Inferrers::NameInferrer.from_controller_name(name)
+      #     @deserializer_class = name_inferrer.deserializer.safe_constantize
+      #   end
+      # end
+      #
+      # def payload
+      #   if request.raw_post.blank?
+      #     raise Errors[400], "The request body can't be empty."
+      #   end
+      #
+      #   deserialize(request.request_parameters[:data])
+      # end
+
+      def redirect_to(url, options = {})
+        status = options[:status] || 307
+        validate_url!(url)
+        validate_redirection_status!(status)
+
+        uri = URI.parse(url)
+        response.set_header('Location', uri.to_s)
+        render(nil, status: status)
+      end
+
+      def render(object, options = {})
+        status = options.delete(:status) || 200
+        renderer_options = jsonapi_params.to_h.merge(options)
+
+        body = serialize(object, renderer_options)
+        update_response(status: status, body: body)
+
+        respond!
+      end
+
+      protected
+
+      # def deserialize(data)
+      #   deserializer_class = self.class.deserializer_class
+      #   if deserializer_class.nil?
+      #     raise Errors[500], 'Could not find a deserializer class.'
+      #   end
+      #
+      #   deserializer = deserializer_class.new(data)
+      #   deserializer.to_h
+      # end
+
+      def jsonapi_params
+        @jsonapi_params ||= JsonapiParameters.new(params)
+      end
+
+      def jsonapi_renderer
+        @jsonapi_renderer ||= JsonapiRenderer.new
+      end
+
+      def serialize(object, options = {})
+        return { data: {} }.to_json if object.nil?
+
+        jsonapi_hash = jsonapi_renderer.render(object, options)
+        jsonapi_hash.to_json
+      end
+    end
+  end
+end