shark-on-lambda 0.0.0 → 0.6.7

data/lib/shark_on_lambda/api_gateway/serializers/base_error_serializer.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module SharkOnLambda
+  module ApiGateway
+    module Errors
+      class BaseSerializer < ::JSONAPI::Serializable::Error
+        id { @object.id }
+        status { @object.status }
+        code { @object.code }
+        title { @object.title }
+        detail { @object.detail }
+        meta { @object.meta }
+        source do
+          pointer @object.pointer if @object.pointer.present?
+          parameter @object.parameter if @object.parameter.present?
+        end
+      end
+    end
+  end
+end

data/lib/shark_on_lambda/concerns/filter_actions.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+module SharkOnLambda
+  module Concerns
+    module FilterActions
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+
+      module ClassMethods
+        def after_action(symbol, only: [], except: [])
+          @after_actions ||= []
+          @after_actions << {
+            symbol: symbol,
+            only: Array(only),
+            except: Array(except)
+          }
+        end
+
+        def after_actions
+          @after_actions || []
+        end
+
+        def before_action(symbol, only: [], except: [])
+          @before_actions ||= []
+          @before_actions << {
+            symbol: symbol,
+            only: Array(only),
+            except: Array(except)
+          }
+        end
+
+        def before_actions
+          @before_actions || []
+        end
+      end
+
+      def call_with_filter_actions(method, *args)
+        run_before_actions(method)
+        result = send(method, *args)
+        run_after_actions(method)
+        result
+      end
+
+      protected
+
+      def after_actions
+        self.class.after_actions
+      end
+
+      def before_actions
+        self.class.before_actions
+      end
+
+      def run_actions(method, actions)
+        actions.each do |action|
+          next if skip_filter_action?(method, action)
+
+          send(action[:symbol])
+        end
+      end
+
+      def run_after_actions(method)
+        run_actions(method, after_actions)
+      end
+
+      def run_before_actions(method)
+        run_actions(method, before_actions)
+      end
+
+      def skip_filter_action?(method, filter_action)
+        only = filter_action[:only]
+        except = filter_action[:except]
+
+        return true if only.any? && !only.include?(method)
+        return true if except.any? && except.include?(method)
+
+        false
+      end
+    end
+  end
+end

data/lib/shark_on_lambda/concerns/resettable_singleton.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module SharkOnLambda
+  module Concerns
+    module ResettableSingleton
+      def self.included(base)
+        base.include(Singleton)
+        base.extend(ClassMethods)
+      end
+
+      module ClassMethods
+        def reset
+          @singleton__instance__ = nil
+        end
+      end
+    end
+  end
+end

data/lib/shark_on_lambda/concerns/yaml_config_loader.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module SharkOnLambda
+  module Concerns
+    module YamlConfigLoader
+      def load_yaml_files(stage:, fallback: :default, paths:)
+        result = HashWithIndifferentAccess.new
+        paths.each do |path|
+          data = load_yaml_file(stage: stage, fallback: fallback, path: path)
+          result.deep_merge!(data)
+        end
+        result
+      end
+
+      protected
+
+      def load_yaml_file(stage:, fallback:, path:)
+        return {} unless File.exist?(path)
+
+        data = YAML.load_file(path)
+        return {} unless data.is_a?(Hash)
+
+        data = data.with_indifferent_access
+        data[stage] || data[fallback] || {}
+      end
+    end
+  end
+end

data/lib/shark_on_lambda/configuration.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module SharkOnLambda
+  class Configuration < OpenStruct
+    include Concerns::ResettableSingleton
+
+    attr_writer :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 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/name_inferrer.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module SharkOnLambda
+  module Inferrers
+    class NameInferrer
+      class << self
+        def from_controller_name(class_name)
+          from_name(:controller, class_name)
+        end
+
+        def from_deserializer_name(class_name)
+          from_name(:deserializer, class_name)
+        end
+
+        def from_handler_name(class_name)
+          from_name(:handler, class_name)
+        end
+
+        def from_model_name(class_name)
+          from_name(:model, class_name)
+        end
+
+        def from_serializer_name(class_name)
+          from_name(:serializer, class_name)
+        end
+
+        protected
+
+        def from_name(type, class_name)
+          base = class_name.underscore
+          base = case type
+                 when :controller, :deserializer, :handler, :serializer
+                   base.sub(/_#{type}\z/, '')
+                 when :model
+                   base
+                 end
+          new(base)
+        end
+      end
+
+      def initialize(base)
+        @base = base
+      end
+
+      def controller
+        "#{@base}_controller".camelize
+      end
+
+      def deserializer
+        "#{@base}_deserializer".camelize
+      end
+
+      def handler
+        "#{@base}_handler".camelize
+      end
+
+      def model
+        @base.camelize
+      end
+
+      def serializer
+        "#{@base}_serializer".camelize
+      end
+    end
+  end
+end

data/lib/shark_on_lambda/inferrers/serializer_inferrer.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module SharkOnLambda
+  module Inferrers
+    class SerializerInferrer
+      def initialize(object_class)
+        @object_class = object_class
+      end
+
+      def serializer_class
+        return @serializer_class if defined?(@serializer_class)
+
+        serializer_class_names.each do |serializer_class_name|
+          @serializer_class = serializer_class_name.safe_constantize
+          break if @serializer_class.present?
+        end
+
+        @serializer_class
+      end
+
+      protected
+
+      def object_class
+        unless @object_class.is_a?(String) || @object_class.is_a?(Symbol)
+          return @object_class
+        end
+
+        @object_class.to_s.camelize.constantize
+      end
+
+      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?
+
+          name_inferrer = NameInferrer.from_model_name(ancestor_name)
+          name_inferrer.serializer
+        end
+        @serializer_class_names.compact! || @serializer_class_names
+      end
+    end
+  end
+end

data/lib/shark_on_lambda/secrets.rb

@@ -0,0 +1,43 @@
+# 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

data/lib/shark_on_lambda/tasks.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+load 'shark_on_lambda/tasks/build.rake'

data/lib/shark_on_lambda/tasks/build.rake

@@ -0,0 +1,146 @@
+# frozen_string_literal: true
+
+require 'shark-on-lambda'
+
+class DockerContainer
+  attr_reader :project_dir, :tag
+  attr_accessor :params, :commands
+
+  def initialize(project_dir:, tag: 'latest')
+    @project_dir = project_dir
+    @tag = tag
+    @params = default_params
+    @commands = default_commands
+  end
+
+  def build
+    sh("cd #{project_dir} && docker build . -t #{name}")
+  end
+
+  def exist?
+    system("docker image inspect #{name} &> /dev/null")
+  end
+
+  def mount_dir
+    File.join('/src', project_name)
+  end
+
+  def name
+    "#{project_name}-builder:#{tag}"
+  end
+
+  def remove
+    sh("docker image rm #{name}")
+  end
+
+  def run
+    arguments = params.join(' ')
+    command = commands.join(' && ')
+
+    sh(%(docker run #{arguments} #{name} /bin/bash -c "#{command}"))
+  end
+
+  def working_dir
+    File.join('/tmp', project_name)
+  end
+
+  protected
+
+  def default_commands
+    [
+      "cp -a #{mount_dir} #{working_dir}",
+      "cd #{working_dir}"
+    ]
+  end
+
+  def default_params
+    [
+      '--rm',
+      "-v #{project_dir}:#{mount_dir}"
+    ]
+  end
+
+  def project_name
+    File.basename(project_dir)
+  end
+
+  def sh(command)
+    puts command
+    system(command)
+  end
+end
+
+def build_stage(stage)
+  container = DockerContainer.new(project_dir: SharkOnLambda.root)
+  Rake::Task['docker:build'].invoke unless container.exist?
+
+  container.commands += build_commands(container, stage: stage)
+  container.run
+end
+
+def deploy_stage(stage)
+  deploy_command = deploy_commands(stage: stage).join(' && ')
+  sh(deploy_command)
+end
+
+def remove_stage(stage)
+  sh("sls remove -v -s #{stage}")
+end
+
+namespace :docker do
+  container = DockerContainer.new(project_dir: SharkOnLambda.root)
+
+  desc 'Build the Docker container required for... building.'
+  task :build do
+    container.build
+  end
+
+  desc 'Remove the Docker container required for building.'
+  task :remove do
+    container.remove
+  end
+end
+
+%i[integration staging production].each do |stage|
+  namespace :build do
+    desc "Build this service for the '#{stage}' stage."
+    task stage => [:clean] do
+      build_stage(stage)
+    end
+  end
+
+  namespace :deploy do
+    desc "Deploy this service to the '#{stage}' stage."
+    task stage => ["build:#{stage}"] do
+      deploy_stage(stage)
+    end
+  end
+
+  namespace :remove do
+    desc "Remove this service from the '#{stage}' stage."
+    task stage do
+      remove_stage(stage)
+    end
+  end
+end
+
+desc 'Build this service for STAGE.'
+task :build, [:stage] => [:clean] do |_, args|
+  build_stage(args.stage)
+end
+
+desc 'Remove package build directory.'
+task :clean do
+  package_dir = SharkOnLambda.root.join('pkg')
+  FileUtils.rm_rf(package_dir)
+end
+
+desc 'Deploy this service to STAGE.'
+task :deploy, [:stage] => [:build] do |_, args|
+  deploy_stage(args.stage)
+end
+
+desc 'Remove this service from STAGE.'
+task :remove, [:stage] do |_, args|
+  remove_stage(args.stage)
+end