hanami-lambda 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e6434425a9bc1477663be14851eb304da6fd9fc5ebe9a9ff3b800afb72986f1d
-  data.tar.gz: 94b184c7584379f57d7214c24e4963e3ca2b66d9a5cac02781e6612254f868a3
+  metadata.gz: c8a8ab1a1e0affa3af3a684eb7f96cf8b4d5f19a18f73cbc9f86a0661726a8cd
+  data.tar.gz: 281445c481e12c80c41e9a217e719eb3306aaa9e8214feedeb9999e7a7347276
 SHA512:
-  metadata.gz: 296484573f0c74479a2f3ddf78f4eef69c8d41e7ae34eae2bc18055aaa17c7d9ad49f843f016555a08c72743272d237e289d64dba5aadc8a7dcb696f9e07d5a4
-  data.tar.gz: d8b969b733db865b342cb55a9e800020ed416922db7061115ff36cb4d391bc76ff78d83f4e49e731e40c512a41ebda80b416d3bece37c559429eba5fed29b507
+  metadata.gz: 59c7fe7721eaf15a3481d418ded8ecf61f6ff5774024c6a6702d413f7792624565b394f99db736013961750e48c801febfb531962a77e39cd38532e619b1f470
+  data.tar.gz: c4abc0406ebb796740201d79e1e00986c08f3b8ea23ec3a7e056943d4ab1b641a3aec90c291edddb86477175fb3cab91c56b7712051ae545b32a181be3b7984a

data/README.md

@@ -10,7 +10,7 @@ Hanami Lambda is a gem that provides a way to run hanami application on AWS Lamb
 
 ## Rubies
 
-**Hanami::Cucumber** supports Ruby (MRI) 3.0+
+**Hanami::Lambda** supports Ruby (MRI) 3.0+
 
 ## Installation
 
@@ -26,14 +26,25 @@ And then execute:
 $ bundle install
 ```
 
-Create `config/lambda.rb` with below content
+Update `config/app.rb` with below content
 
 ```ruby
+require 'hanami'
 require 'hanami/lambda'
 
 module MyApp # Rename to your app name
-    class Lambda < Hanami::Lambda::Application
-    end
+  class Lambda < Hanami::App
+    extend Hanami::Lambda::Application
+  end
+end
+```
+
+Create `app/function.rb` as handler base class
+
+```ruby
+module MyApp
+  class Function < Hanami::Lambda::Function
+  end
 end
 ```
 
@@ -44,17 +55,45 @@ end
 Use `config/lambda.Hanami::Lambda.call` as the function handler
 
 ```yaml
+# AWS SAM
 Resources:
-  ExampleHandler:
+  MyFunction:
     Type: AWS::Serverless::Function
-    Name: "example-api"
     Properties:
       CodeUri: .
       Handler: config/lambda.Hanami::Lambda.call
       Runtime: ruby3.2
 ```
 
-> Currently, the only `APIGateWay` event is supported
+### Delegate
+
+If the lambda function isn't trigger by APIGateway, we can use `delegate` method to define the handler function.
+
+Create `config/lambda.rb` with below content
+
+```ruby
+module MyApp
+  class Lambda < Hanami::Lambda::Dispatcher
+    delegate "MyFunction", to: "daily_task"
+  end
+end
+```
+
+> The IaC generated function will be `my-app-MyFunction-r8faNAo3iUqx` therefore the dispatcher will use include `MyFunction` to find targeted function
+
+Add `app/functions/daily_task.rb` to define the handle action
+
+```ruby
+module MyApp
+  module Functions
+    class DailyTask < MyApp::Function
+      def handle(event, context)
+        # ...
+      end
+    end
+  end
+end
+```
 
 ## Development
 

data/lib/hanami/errors.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Hanami
+  module Lambda
+    # Base error for Hanami::Lambda
+    #
+    # @api public
+    # @since 0.2.0
+    Error = Class.new(StandardError)
+
+    # Raised when {Hanami::Lambda::Application} fails to load.
+    #
+    # @api public
+    # @since 0.2.0
+    AppLoadError = Class.new(Error)
+  end
+end

data/lib/hanami/lambda/application.rb

@@ -2,34 +2,62 @@
 
 module Hanami
   module Lambda
+    HANDLER_KEY_NAMESPACE = "functions"
+
     # The application to configure for AWS Lambda.
     #
     # @since 0.1.0
-    class Application
+    module Application
+      # @since 0.2.0
+      # @api private
+      def self.extended(base)
+        base.class_eval do
+          prepare_load_path if respond_to?(:prepare_load_path)
+        end
+      end
+
+      # Dispatch event to the handler
+      #
       # @api private
-      def self.inherited(subclass)
-        super
+      # @since 0.1.0
+      def handle_lambda(event:, context:)
+        lambda_dispatcher.call(event: event, context: context)
+      end
 
-        Hanami::Lambda.app = subclass
-        subclass.extend(ClassMethods)
+      # Get lambda dispatcher
+      #
+      # @return [Hanami::Lambda::Dispatcher] the dispatcher
+      #
+      # @since 0.1.0
+      def lambda_dispatcher
+        @lambda_dispatcher ||= load_lambda_dispatcher
       end
 
-      module ClassMethods
-        # Dispatch event to the handler
-        #
-        # @api private
-        # @since 0.1.0
-        def call(event:, context:)
-          handler = lookup(event: event, context: context)
-          handler.call
+      # Load lambda dispatcher
+      #
+      # @return [Hanami::Lambda::Dispatcher] the dispatcher
+      #
+      # @since 0.2.0
+      # @api private
+      def load_lambda_dispatcher
+        if root.directory?
+          dispatcher_path = File.join(root, LAMBDA_CONFIG_PATH)
+
+          begin
+            require dispatcher_path
+          rescue LoadError => exception
+            raise exception unless exception.path == dispatcher_path
+          end
         end
 
-        # Lookup the handler for the given event
-        #
-        # @api private
-        # @since 0.1.0
-        def lookup(event:, context:)
-          Rack.new(Hanami.app, event: event, context: context)
+        begin
+          dispatcher_class = namespace.const_get(LAMBDA_CLASS_NAME)
+          dispatcher_class.build(
+            rack_app: app.rack_app,
+            resolver: ->(to) { app.resolve("#{HANDLER_KEY_NAMESPACE}.#{to}") }
+          )
+        rescue NameError => exception
+          raise exception unless exception.name == LAMBDA_CLASS_NAME
         end
       end
     end

data/lib/hanami/lambda/dispatcher.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+module Hanami
+  module Lambda
+    # Dispatch Event to the Handler
+    #
+    # @api private
+    class Dispatcher
+      # @since 0.2.0
+      # @api private
+      DEFAULT_RESOLVER = ->(to) { to }
+
+      attr_reader :rack_app, :handlers, :default, :resolver
+
+      # @since 0.2.0
+      def initialize(rack_app:, resolver: DEFAULT_RESOLVER)
+        @handlers = {}
+        @resolver = resolver
+        @default = Rack.new(rack_app)
+      end
+
+      # Call the handler
+      #
+      # @param event [Hash] the event
+      # @param context [Hash] the context
+      #
+      # @since 0.2.0
+      def call(event:, context:)
+        handler = lookup(event: event, context: context)
+        return default.call(event: event, context: context) unless handler
+
+        handler.call(event: event, context: context)
+      end
+
+      # Lookup the handler
+      #
+      # @param event [Hash] the event
+      # @param context [Hash] the context
+      #
+      # @return [Handler] the handler
+      def lookup(event:, context:) # rubocop:disable Lint/UnusedMethodArgument
+        function_name = ENV.fetch("AWS_LAMBDA_FUNCTION_NAME", context.function_name)
+        handlers
+          .select { |name, _| function_name.include?(name) }
+          .max_by { |name, _| name.length }
+          &.last
+      end
+
+      # Register a handler
+      #
+      # @param name [String] the name of the handler
+      # @param args [Array] the arguments to pass to the handler
+      # @param kwargs [Hash] the keyword arguments to pass to the handler
+      # @param block [Proc] the block to pass to the handler
+      #
+      # @since 0.2.0
+      def register(name, to: nil)
+        handlers[name] =
+          if to.nil?
+            @default
+          else
+            resolver.call(to)
+          end
+      end
+
+      class << self
+        # Definitions of handlers
+        #
+        # @api private
+        def definitions
+          @definitions ||= []
+        end
+
+        # Define function delegate action
+        #
+        # @param name [String] the name of the handler
+        # @param args [Array] the arguments to pass to the handler
+        # @param kwargs [Hash] the keyword arguments to pass to the handler
+        # @param block [Proc] the block to pass to the handler
+        def delegate(name, *args, **kwargs, &block)
+          definitions << [name, args, kwargs, block]
+        end
+
+        # Build Dispatcher
+        #
+        # @api private
+        def build(rack_app:, resolver:)
+          new(rack_app: rack_app, resolver: resolver).tap do |dispatcher|
+            definitions.each do |(name, args, kwargs, block)|
+              if block
+                dispatcher.register(name, *args, **kwargs, &block)
+              else
+                dispatcher.register(name, *args, **kwargs)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/hanami/lambda/event.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require "hanami/utils/hash"
+
+module Hanami
+  module Lambda
+    # Base event class
+    #
+    # @since 0.2.0
+    class Event
+      attr_reader :raw
+
+      # @param event [Hash] the raw event from AWS Lambda
+      # @return [Hanami::Lambda::Event]
+      #
+      # @since 0.2.0
+      def initialize(event)
+        @raw = event
+        @event = Hanami::Utils::Hash.deep_symbolize(@raw)
+        freeze
+      end
+
+      # Return the value of the given key
+      #
+      # @param key [Symbol] the key to fetch
+      #
+      # @return [Object,NilClass] the associated value if found
+      #
+      # @since 0.2.0
+      def [](key)
+        @event[key]
+      end
+
+      # Return an value associated with the given event key
+      #
+      # @param keys [Array<Symbol, Integer>] the keys to fetch
+      #
+      # @return [Object,NilClass] the associated value if found
+      #
+      # @since 0.2.0
+      def get(*keys)
+        @event.dig(*keys)
+      end
+      alias_method :dig, :get
+
+      # Return the hash of the event
+      #
+      # @return [Hash] the hash of the event
+      #
+      # @since 0.2.0
+      def to_h
+        @event
+      end
+    end
+  end
+end

data/lib/hanami/lambda/events/base.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Hanami
+  module Lambda
+    module Events
+      class Base < Dry::Struct
+        transform_keys do |key|
+          Hanami::Lambda.inflector.underscore(key).to_sym
+        end
+      end
+    end
+  end
+end

data/lib/hanami/lambda/events/event_bridge.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Hanami
+  module Lambda
+    module Events
+      class EventBridge < Base
+        attribute :version, Types::Integer
+        attribute :id, Types::String
+        attribute :detail_type, Types::String
+        attribute :source, Types::String
+        attribute :account, Types::String
+        attribute :time, Types::Time
+        attribute :region, Types::String
+        attribute :resources, Types::Array.of(Types::String)
+        attribute :detail, Types::String
+      end
+    end
+  end
+end

data/lib/hanami/lambda/function.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module Hanami
+  module Lambda
+    # The base class for handler
+    #
+    # @since 0.2.0
+    class Function
+      # Override the Ruby's hook for modules
+      #
+      # @param base [Class] the target class
+      #
+      # @since 0.2.0
+      # @api private
+      def self.inherited(subclass)
+        super
+
+        subclass.extend ClassMethods
+
+        if instance_variable_defined?(:@event_type)
+          subclass.instance_variable_set(:@event_type, @event_type)
+        end
+      end
+
+      module ClassMethods
+        # Return the class which define the event type
+        #
+        # @return [Class] the class which define the event type
+        #
+        # @since 0.2.0
+        # @api private
+        def event_type
+          @event_type || Event
+        end
+
+        # Define the event type
+        #
+        # @param klass [Class] the class which define the event type
+        #
+        # @since 0.2.0
+        # @api private
+        def type(klass)
+          @event_type = klass
+        end
+      end
+
+      # @since 0.2.0
+      def call(event:, context:)
+        event = self.class.event_type.new(event)
+        handle(event, context)
+      end
+
+      protected
+
+      def handle(_event, _context); end
+    end
+  end
+end

data/lib/hanami/lambda/rack.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "rack"
+
 module Hanami
   module Lambda
     # Rack interface for AWS Lambda.
@@ -7,13 +9,13 @@ module Hanami
     # @api private
     # @since 0.1.0
     class Rack
-      attr_reader :app, :event, :context
+      attr_reader :app
 
-      # @api private
-      def initialize(app, event:, context:)
+      # Initialize the Rack interface
+      #
+      # @since 0.1.0
+      def initialize(app)
         @app = app
-        @event = event
-        @context = context
       end
 
       # Handle the request
@@ -21,7 +23,8 @@ module Hanami
       # @return [Hash] the response
       #
       # @since 0.1.0
-      def call
+      def call(event:, context:)
+        env = build_env(event, context)
         status_code, headers, body = app.call(env)
 
         {
@@ -36,12 +39,14 @@ module Hanami
       # @return [Hash] the Rack environment
       #
       # @since 0.1.0
-      def env
+      def build_env(event, context)
         {
           ::Rack::REQUEST_METHOD => event["httpMethod"],
           ::Rack::PATH_INFO => event["path"] || "",
           ::Rack::VERSION => ::Rack::VERSION,
-          ::Rack::RACK_INPUT => StringIO.new(event["body"] || "")
+          ::Rack::RACK_INPUT => StringIO.new(event["body"] || ""),
+          ::Hanami::Lambda::LAMBDA_EVENT => event,
+          ::Hanami::Lambda::LAMBDA_CONTEXT => context
         }
       end
     end

data/lib/hanami/lambda/types.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require "dry-struct"
+
+module Hanami
+  module Lambda
+    module Types
+      include Dry.Types(default: :params)
+    end
+  end
+end

data/lib/hanami/lambda/version.rb

@@ -2,6 +2,6 @@
 
 module Hanami
   module Lambda
-    VERSION = "0.1.0"
+    VERSION = "0.2.0"
   end
 end

data/lib/hanami/lambda.rb

@@ -1,6 +1,8 @@
 # frozen_string_literal: true
 
 require "zeitwerk"
+require "dry-struct"
+require "hanami"
 
 # @see Hanami::Lambda
 # @since 0.1.0
@@ -10,41 +12,52 @@ module Hanami
   # @since 0.1.0
   # @api private
   module Lambda
+    # @since 0.1.0
+    LAMBDA_EVENT = "lambda.event"
+
+    # @since 0.1.0
+    LAMBDA_CONTEXT = "lambda.context"
+
+    # @since 0.2.0
+    LAMBDA_CONFIG_PATH = File.join("config", "lambda")
+
+    # @since 0.2.0
+    LAMBDA_CLASS_NAME = "Lambda"
+
     @_mutex = Mutex.new
 
-    # Returns the Hanami::Lambda application.
-    #
-    # @return [Hanami::Lambda::Application] the application
-    # @raise [Hanami::AppLoadError] if the application isn't configured
+    # Return the application
     #
     # @api public
     # @since 0.1.0
+    #
+    # @return [Hanami::Lambda::Application] the application
     def self.app
-      @_mutex.synchronize do
-        unless defined?(@_app)
-          raise Hanami::AppLoadError,
-                "Hanami::Lambda.app is not yet configured. "
-        end
+      Hanami.app
+    end
 
-        @_app
-      end
+    # Run the application
+    #
+    # @api public
+    def self.call(event:, context:)
+      app.boot
+      app.handle_lambda(event: event, context: context)
     end
 
+    # Inflector to convert event key
+    #
+    # @return [Dry::Inflector]
+    #
+    # @since 0.2.0
     # @api private
-    # @since 0.1.0
-    def self.app=(klass)
+    def self.inflector
       @_mutex.synchronize do
-        raise AppLoadError, "Hanami::Lambda.app is already configured." if instance_variable_defined?(:@_app)
+        return @inflector if defined?(@inflector)
 
-        @_app = klass unless klass.name.nil?
+        @inflector ||= Dry::Inflector.new
       end
-    end
-
-    def self.call(event:, context:)
-      require "hanami/setup"
 
-      Hanami.boot
-      app.call(event: event, context: context)
+      @inflector
     end
 
     # @since 0.1.0

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: hanami-lambda
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Aotokitsuruya
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-01-01 00:00:00.000000000 Z
+date: 2024-01-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: zeitwerk
@@ -24,6 +24,62 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '2.6'
+- !ruby/object:Gem::Dependency
+  name: hanami
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: hanami-utils
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: dry-struct
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: dry-inflector
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
 - !ruby/object:Gem::Dependency
   name: rubocop
   requirement: !ruby/object:Gem::Requirement
@@ -52,9 +108,16 @@ files:
 - README.md
 - Rakefile
 - lib/hanami-lambda.rb
+- lib/hanami/errors.rb
 - lib/hanami/lambda.rb
 - lib/hanami/lambda/application.rb
+- lib/hanami/lambda/dispatcher.rb
+- lib/hanami/lambda/event.rb
+- lib/hanami/lambda/events/base.rb
+- lib/hanami/lambda/events/event_bridge.rb
+- lib/hanami/lambda/function.rb
 - lib/hanami/lambda/rack.rb
+- lib/hanami/lambda/types.rb
 - lib/hanami/lambda/version.rb
 - sig/hanami/lambda.rbs
 homepage: https://github.com/elct9620/hanami-lambda