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

data/lib/shark_on_lambda/jsonapi_controller.rb

@@ -1,29 +0,0 @@
-# frozen_string_literal: true
-
-module SharkOnLambda
-  class JsonapiController < BaseController
-    ActionController::Renderers.add :jsonapi do |object, options|
-      response.set_header('content-type', 'application/vnd.api+json')
-      return { data: {} }.to_json if object.nil?
-
-      jsonapi_params = JsonapiParameters.new(params)
-      jsonapi_renderer = JsonapiRenderer.new
-      render_options = jsonapi_params.to_h.deep_merge(options)
-
-      jsonapi_renderer.render(object, render_options)
-    end
-
-    def redirect_to(options = {}, response_status = {})
-      super
-      return if response_status[:status] == 304
-
-      self.response_body = { data: {} }.to_json
-    end
-
-    def render(object, options = {})
-      options.merge!(jsonapi: object, content_type: 'application/vnd.api+json')
-
-      super(options)
-    end
-  end
-end

data/lib/shark_on_lambda/middleware/rescuer.rb

@@ -1,38 +0,0 @@
-# frozen_string_literal: true
-
-module SharkOnLambda
-  module Middleware
-    class Rescuer < Base
-      private
-
-      def _call(env)
-        app.call(env)
-      rescue Errors::Base => e
-        rescue_shark_error(e)
-      rescue StandardError => e
-        rescue_standard_error(e)
-      end
-
-      def error_response(status, headers, message)
-        response_body = Rack::BodyProxy.new([message]) do
-          message.close if message.respond_to?(:close)
-        end
-
-        [status, headers, response_body]
-      end
-
-      def rescue_shark_error(error)
-        status = error.status || 500
-        error_response(status, {}, error.message)
-      end
-
-      def rescue_standard_error(error)
-        SharkOnLambda.logger.error(error.message)
-        SharkOnLambda.logger.error(error.backtrace.join("\n"))
-        Honeybadger.notify(error) if defined?(Honeybadger)
-
-        error_response(500, {}, error.message)
-      end
-    end
-  end
-end

data/lib/shark_on_lambda/query.rb

@@ -1,67 +0,0 @@
-# frozen_string_literal: true
-
-module SharkOnLambda
-  # The `multiValueQueryStringParameters` object from the API Gateway event
-  # keeps _all_ values in an array, regardless of the actual size of the array
-  # and regardless of the "intent" of the query string parameter.
-  #
-  # In order to normalise this behaviour, we treat the query strings
-  #
-  #   `key=value1&key=value2`
-  #
-  # and
-  #
-  #   `key[]=value1&key[]=value2`
-  #
-  # the same. Both are to be serialised to the query string
-  #
-  #   `key[]=value1&key[]=value2`
-  #
-  # However, the query strings
-  #
-  #   `key=value`
-  #
-  # and
-  #
-  #   `key[]=value`
-  #
-  # are _not_ to be treated the same.
-  class Query
-    def initialize(data = {})
-      @params = HashWithIndifferentAccess.new.merge(data)
-    end
-
-    def add(key, values)
-      if key.to_s.end_with?('[]')
-        actual_key = key[0..-3]
-        add_list(actual_key, values)
-      else
-        values.each { |value| add_item(key, value) }
-      end
-    end
-
-    def to_h
-      @params
-    end
-
-    def to_s
-      Rack::Utils.build_nested_query(to_h)
-    end
-
-    private
-
-    def add_item(key, value)
-      if @params[key].nil?
-        @params[key] = value
-      else
-        @params[key] = Array(@params[key])
-        @params[key] << value
-      end
-    end
-
-    def add_list(key, value)
-      @params[key] ||= []
-      @params[key].concat(value)
-    end
-  end
-end

data/lib/shark_on_lambda/rack_adapters/api_gateway.rb

@@ -1,128 +0,0 @@
-# frozen_string_literal: true
-
-module SharkOnLambda
-  module RackAdapters
-    class ApiGateway
-      attr_reader :context, :event
-
-      def initialize(context:, event:)
-        @context = context
-        @event = event.deep_stringify_keys
-      end
-
-      def build_response(status, headers, body)
-        body_content = ''
-        body.each { |line| body_content += line.to_s }
-        response = {
-          'statusCode' => status,
-          'headers' => headers,
-          'body' => body_content
-        }
-        response['isBase64Encoded'] = false if elb?
-        response
-      end
-
-      def env
-        default_env.merge(env_request_metadata)
-                   .merge(env_headers)
-                   .merge(env_params)
-                   .merge(env_body)
-      end
-
-      private
-
-      def default_env
-        {
-          'SCRIPT_NAME' => '',
-          'rack.version' => Rack::VERSION,
-          'rack.errors' => $stderr,
-          'rack.multithread' => true,
-          'rack.multiprocess' => true,
-          'rack.run_once' => false
-        }
-      end
-
-      def elb?
-        return false if event['requestContext'].nil?
-
-        event['requestContext'].key?('elb')
-      end
-
-      def env_body
-        result = event['body'] || ''
-        result = Base64.decode64(result) if event['isBase64Encoded']
-
-        {
-          'rack.input' => StringIO.new(result).set_encoding(Encoding::BINARY),
-          'CONTENT_LENGTH' => result.bytesize.to_s
-        }
-      end
-
-      def env_headers
-        result = {}
-        http_headers.each_pair do |header, value|
-          key = key_for_header(header)
-          result[key] = value.to_s
-        end
-        result
-      end
-
-      def env_params
-        {
-          'QUERY_STRING' => query_string,
-          'shark.path_parameters' => event['pathParameters']
-        }
-      end
-
-      def env_request_metadata
-        {
-          'REQUEST_METHOD' => event['httpMethod'],
-          'PATH_INFO' => path_info,
-          'SERVER_NAME' => server_name,
-          'SERVER_PORT' => server_port.to_s,
-          'rack.url_scheme' => url_scheme
-        }
-      end
-
-      def http_headers
-        event['headers'] || {}
-      end
-
-      def key_for_header(header)
-        key = header.upcase.tr('-', '_')
-        case key
-        when 'CONTENT_LENGTH', 'CONTENT_TYPE' then key
-        else "HTTP_#{key}"
-        end
-      end
-
-      def path_info
-        event['path'] || ''
-      end
-
-      def query_string
-        return @query_string if defined?(@query_string)
-
-        query = Query.new
-        event['multiValueQueryStringParameters']&.each_pair do |key, value|
-          query.add(key, value)
-        end
-        @query_string = query.to_s
-      end
-
-      def server_name
-        http_headers['Host'] || 'localhost'
-      end
-
-      def server_port
-        http_headers['X-Forwarded-Port'] || 443
-      end
-
-      def url_scheme
-        http_headers['CloudFront-Forwarded-Proto'] ||
-          http_headers['X-Forwarded-Proto'] ||
-          'https'
-      end
-    end
-  end
-end

data/lib/shark_on_lambda/secrets.rb

@@ -1,43 +0,0 @@
-# frozen_string_literal: true
-
-module SharkOnLambda
-  class Secrets < OpenStruct
-    include Concerns::ResettableSingleton
-
-    class << self
-      include Concerns::YamlConfigLoader
-
-      attr_writer :files
-
-      def load(stage, fallback: :default)
-        load_secrets(stage, fallback: fallback)
-
-        instance
-      end
-
-      def files
-        return @files if defined?(@files)
-
-        @files = paths(%w[config/secrets.yml config/secrets.local.yml])
-      end
-
-      protected
-
-      def load_secrets(stage, fallback:)
-        secrets = load_yaml_files(stage: stage,
-                                  fallback: fallback,
-                                  paths: files)
-        secrets.each_pair { |key, value| instance.send("#{key}=", value) }
-      end
-
-      def paths(files)
-        files.map { |file| SharkOnLambda.config.root.join(file) }
-      end
-    end
-
-    def inspect
-      # Do not display all the internals of this object when #inspect is called.
-      "#<#{self.class.name}>"
-    end
-  end
-end