shark-on-lambda 1.0.1 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e65d5fd63a3fe9849667d0a023286a7ec8b4c78e868d3576dfd8c229d627e7d1
-  data.tar.gz: c30474a3ce2381caf7bf5e75e76d0ec441efef525554819ce1c6bc46e8cbec50
+  metadata.gz: 224a4b3bddf92d9409d38d0ad65bae7511e05c0d9d40d8d2b1b6ba5c4224f6e0
+  data.tar.gz: 46a5ac6faeac926b023069ad953fb2b96340f969a9dcc8df116e29d6536999a2
 SHA512:
-  metadata.gz: 5c1ab8d3c7aedcd042dace73a1771a755fc3210e65a2a229591325e96902925f3b5aa5e6ee7efdde8890862a6059ba7be365d562f1a0f82216de10d7a495c42e
-  data.tar.gz: 34398cf95e10a12e576735a0f09ac4b269301d48d9f34ce441f0d8d232d812173ab001181f215f2ceea9012e60372c54b97c5653e407a719edf2fadf63ef3900
+  metadata.gz: 5cb73c903cddc2898212b09cc314f9cf35df9f099e8f21eba27df660b2d20ae78c6a828ab29e32a46e433e6485031e1609848c6af49fc53307c04651861d90c6
+  data.tar.gz: 92f7f4ab12057333a45089f8734c081dab440f22d42bbb6c72de0057e24cfb444089b72ffe1d3c2207ddd70e8d13ae16c88170807dbd6e68a5fd319ed65d0a84

data/.rubocop.yml

@@ -1,4 +1,5 @@
 AllCops:
+  NewCops: enable
   TargetRubyVersion: 2.5
 
 Metrics/BlockLength:
@@ -6,6 +7,9 @@ Metrics/BlockLength:
     - 'spec/**/*_spec.rb'
     - 'spec/factories/*.rb'
 
+Layout/LineLength:
+  Max: 80
+
 Naming/FileName:
   Exclude:
     - lib/shark-on-lambda.rb

data/changelog.md

@@ -2,6 +2,18 @@
 
 #### Unreleased
 
+#### 2.0.0
+- [Deprecate] Requiring `shark-on-lambda` is marked as deprecated in favour of requiring `shark_on_lambda`.
+- [Break] `SharkOnLambda::Dispatcher` was removed in favour of routing via `ActionDispatch::Routing`.
+- [Break] `SharkOnLambda::BaseController` now renders _JSON API_-compliant responses.
+- [Break] `SharkOnLambda::JsonapiController` was removed.
+- [Break] Support for `path_parameters` in RSpec helpers was removed.
+- [Break] Configuration files are not loaded automatically anymore.
+- Added `SharkOnLambda::Cacheable`.
+- Added `SharkOnLambda.cache` and `SharkOnLambda.global_cache`.
+- Added support for routing.
+- Use `rack-on-lambda` as an adapter for events from the (REST API flavoured) API Gateway.
+
 #### 1.0.1
 
 - [Fix] `Jsonapi::Renderer#render` should always return a hash.

data/doc/upgrade-from-0.6.x-to-1.x.md

@@ -31,13 +31,13 @@ your RSpec tests and then use the methods `delete`, `get`, `patch`, `post`, or
 
 ```ruby
 RSpec.describe MyController do
-  let!(:service_token) { 'my-super-secret-service-token' }
-  let!(:headers) do
+  let(:service_token) { 'my-super-secret-service-token' }
+  let(:headers) do
     {
       'authorization' => "Bearer #{service_token}"
     }
   end    
-  let!(:params) do
+  let(:params) do
     {
       id: 1
     }

data/lib/shark-on-lambda.rb

@@ -1,3 +1,12 @@
 # frozen_string_literal: true
 
+require 'active_support/core_ext/string'
+require 'active_support/deprecation'
+
+deprecation_message = <<-MESSAGE.squish
+  Requiring `shark-on-lambda` is deprecated and will be removed in version 3.0. 
+  Please require `shark_on_lambda` instead.
+MESSAGE
+ActiveSupport::Deprecation.warn(deprecation_message, caller(2))
+
 require 'shark_on_lambda'

data/lib/shark_on_lambda.rb

@@ -2,6 +2,7 @@
 
 require 'pry' if Gem.loaded_specs.key?('pry')
 
+require 'erb'
 require 'forwardable'
 require 'ostruct'
 require 'pathname'
@@ -14,6 +15,7 @@ require 'active_support/all'
 require 'jsonapi/deserializable'
 require 'jsonapi/serializable'
 require 'rack/utils'
+require 'rack-on-lambda'
 require 'yaml'
 require 'zeitwerk'
 
@@ -22,6 +24,7 @@ module SharkOnLambda; end
 
 Zeitwerk::Loader.for_gem.tap do |loader|
   loader.ignore(File.expand_path('shark-on-lambda.rb', __dir__))
+  loader.ignore(File.expand_path('shark_on_lambda/rake_tasks.rb', __dir__))
   loader.inflector.inflect(
     'rspec' => 'RSpec',
     'version' => 'VERSION'
@@ -35,75 +38,32 @@ module SharkOnLambda
   class << self
     extend Forwardable
 
-    attr_writer :logger
+    attr_writer :application, :cache, :env, :global_cache, :logger
 
-    def_instance_delegators :config, :root, :stage
+    def_instance_delegators :application, :initialize!, :root
 
     def application
       @application ||= Application.new
     end
 
-    def config
-      Configuration.instance
+    def configuration
+      application.config
     end
 
-    def configure
-      yield(config, secrets)
+    def cache
+      @cache ||= ActiveSupport::Cache::NullStore.new
     end
 
-    def initialize!
-      enable_jsonapi!
-
-      yield(config, secrets)
-
-      Configuration.load(stage)
-      Secrets.load(stage)
-      run_initializers
-
-      true
+    def env
+      @env || ENV['STAGE'].presence || 'development'
     end
 
-    def load_configuration
-      Configuration.load(stage)
-      Secrets.load(stage)
-
-      true
+    def global_cache
+      @global_cache ||= ActiveSupport::Cache::NullStore.new
     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
-
-    private
-
-    def enable_jsonapi!
-      ::Mime::Type.register('application/vnd.api+json', :jsonapi)
-      ::ActionDispatch::Request.parameter_parsers[:jsonapi] =
-        ::ActionDispatch::Request.parameter_parsers[:json].dup
-    end
-
-    def run_initializers
-      initializers_path = root.join('config', 'initializers')
-      Dir.glob(initializers_path.join('*.rb')).each do |path|
-        load path
-      end
+      @logger ||= Logger.new($stdout)
     end
   end
 end

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,14 +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.call!(env)
     end
 
     def call!(env)
-      dispatcher = SharkOnLambda.config.dispatcher
-      middleware_stack = SharkOnLambda.config.middleware.build(dispatcher)
+      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 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