lambda-microvms 0.0.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: de35523913c4cd5c11fc48549081c7901db9fdacfef2a72618264885596bb838
-  data.tar.gz: 960ec7995dc496da3f358c6ad484eb0a420140afa727275b92e5eadf7201ce2b
+  metadata.gz: c2278501b187e57ed03eacd396649c19e09bd5c6e07e890f5ce0403588c8f2fb
+  data.tar.gz: c8f240355cdc41e80e5d1d31a231e31cac3e6fd77d488f584e1027df0a47db0a
 SHA512:
-  metadata.gz: 055d951f5d0a5dc948195eff437d7b67070faf74e5dba4eee65b583aa70fda29a0452d93ecbe4e311bf3e7f5f18054d999776c6c5294bc2c88b061c8a777c77c
-  data.tar.gz: 6948f65e7391fa14734dcd1f89757bfb6a1b2a04ee200566409de0851da3a80f41a7173607cbd6efa40a5bc31d09d1033237512eb145bf23358459871dd77da5
+  metadata.gz: 22bc5c257c1650f571cdf560a4c32af34cd119341776cb42a707104620255bbd0e26091b4967acc88462ca873e8319c5109aa9ee46fa26ceb0634207c32526bd
+  data.tar.gz: 942370b040e49ece5f159226f0da4094f05b054c7636210150f2858d768c863e9deb3997d72dff212c707542812134a230850f2ebef06b8478c9af089c288f72

data/CHANGELOG.md

@@ -1,6 +1,15 @@
 # Changelog
 
-## 0.1.0 Unreleased
+## Unreleased
+
+## 0.2.0
+
+- Added `lambda-microvms sdk-contract` and doctor output for the experimental MicroVM SDK operation contract.
+- Added an adapter boundary for MicroVM SDK operations.
+- Added `Lambda::MicroVMs::FunctionClient` and `lambda-microvms function-invoke` for standard Lambda function APIs.
+- Made MicroVM deploy/run fail before packaging or uploading when the installed `aws-sdk-lambda` lacks MicroVM operations.
+
+## 0.1.0
 
 - Initial Ruby development kit for AWS Lambda MicroVMs.
 - Client wrapper over `aws-sdk-lambda`.

data/README.md

@@ -5,9 +5,9 @@
 [![Ruby Version](https://img.shields.io/badge/ruby-%3E%3D%203.2-ruby.svg)](https://www.ruby-lang.org/en/)
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
 
-A Ruby development kit for AWS Lambda MicroVMs.
+A Ruby development kit for AWS Lambda MicroVM experiments and standard Lambda function workflows.
 
-`lambda-microvms` builds on the official `aws-sdk-lambda` gem. It provides Ruby resource objects, lifecycle helpers, endpoint calls, project scaffolding, packaging, and deployment commands for Lambda MicroVM applications.
+`lambda-microvms` builds on the official `aws-sdk-lambda` gem. It provides Ruby resource objects, lifecycle helpers, endpoint calls, project scaffolding, packaging, experimental MicroVM deployment commands, and a supported Lambda function client for APIs that exist today.
 
 It gives Ruby developers a higher-level workflow:
 
@@ -77,7 +77,15 @@ gem "aws_lambda_ric"
 lambda-microvms doctor
 ```
 
-Checks Ruby, Docker, AWS CLI, project config, Dockerfile, deployment bucket, runtime role, and `aws_lambda_ric` presence.
+Checks Ruby, Docker, AWS CLI, project config, Dockerfile, deployment bucket, runtime role, `aws_lambda_ric` presence, and whether the installed `aws-sdk-lambda` exposes the experimental MicroVM operation contract.
+
+## Check the MicroVM SDK contract
+
+```bash
+lambda-microvms sdk-contract
+```
+
+The public `aws-sdk-lambda` gem may not expose MicroVM lifecycle operations such as `create_microvm_image` or `run_microvm`. When those methods are missing, MicroVM `deploy` and `run` fail before packaging or uploading artifacts.
 
 ## Package
 
@@ -113,6 +121,30 @@ lambda-microvms run
 
 Runs the configured image ARN with the configured role ARN and runtime payload.
 
+## Standard Lambda function APIs
+
+The gem also includes a supported path for regular Lambda function APIs available in `aws-sdk-lambda` today.
+
+```ruby
+client = Lambda::MicroVMs::FunctionClient.new(region: "us-east-1")
+
+client.create_function(
+  name: "ruby-worker",
+  role_arn: "arn:aws:iam::123456789012:role/lambda-runtime",
+  handler: "app.Handler.process",
+  runtime: "ruby3.4",
+  zip_file: "tmp/function.zip"
+)
+
+result = client.invoke(function_name: "ruby-worker", payload: { hello: "world" })
+```
+
+You can also invoke an existing function from the CLI:
+
+```bash
+lambda-microvms function-invoke ruby-worker '{"hello":"world"}'
+```
+
 ## Ruby SDK usage
 
 ```ruby
@@ -169,6 +201,7 @@ Lambda::MicroVMs::Client
         ├── MicroVM
         ├── Endpoint
         ├── Session
+        ├── FunctionClient
         ├── Scaffold
         ├── Packager
         └── Deployer
@@ -176,4 +209,6 @@ Lambda::MicroVMs::Client
 
 ## Status
 
-This is an early implementation. Lambda MicroVMs is new, so generated AWS SDK operation shapes may evolve. Unsupported low-level operations raise `Lambda::MicroVMs::UnsupportedOperationError` with an upgrade hint.
+MicroVM lifecycle support is experimental and contract-gated. The current public `aws-sdk-lambda` may not expose the MicroVM methods this gem wraps. Use `lambda-microvms sdk-contract` to verify your installed SDK.
+
+Standard Lambda function operations are available through `Lambda::MicroVMs::FunctionClient`.

data/exe/lambda-microvms

@@ -7,23 +7,33 @@ module Lambda
   module MicroVMs
     # Minimal CLI for the Ruby Lambda MicroVM development kit.
     class CLI
+      COMMANDS = {
+        'version' => :version,
+        '--version' => :version,
+        '-v' => :version,
+        'new' => :new_project,
+        'package' => :package,
+        'deploy' => :deploy,
+        'run' => :run_microvm,
+        'doctor' => :doctor,
+        'sdk-contract' => :sdk_contract,
+        'function-invoke' => :function_invoke,
+        'help' => :help
+      }.freeze
+
       def initialize(argv, out: $stdout, err: $stderr)
         @argv = argv
         @out = out
         @err = err
       end
 
-      # rubocop:disable Metrics/MethodLength
       def run
         command = @argv.shift
-        case command
-        when 'version', '--version', '-v' then version
-        when 'new' then new_project
-        when 'package' then package
-        when 'deploy' then deploy
-        when 'run' then run_microvm
-        when 'doctor' then doctor
-        when 'help', nil then help
+        action = COMMANDS[command]
+        if action
+          send(action)
+        elsif command.nil?
+          help
         else
           @err.puts "unknown command: #{command}"
           help
@@ -33,7 +43,6 @@ module Lambda
         @err.puts "error: #{e.message}"
         1
       end
-      # rubocop:enable Metrics/MethodLength
 
       private
 
@@ -81,6 +90,25 @@ module Lambda
         checks.all?(&:ok) ? 0 : 1
       end
 
+      def sdk_contract
+        unsupported = Client.unsupported_operations
+        if unsupported.empty?
+          @out.puts 'Aws::Lambda::Client exposes all Lambda MicroVM operations'
+          0
+        else
+          @err.puts "missing Aws::Lambda::Client operations: #{unsupported.join(', ')}"
+          1
+        end
+      end
+
+      def function_invoke
+        function_name = @argv.shift || raise(ArgumentError, 'usage: lambda-microvms function-invoke NAME [JSON]')
+        payload = @argv.empty? ? nil : JSON.parse(@argv.join(' '))
+        result = FunctionClient.new.invoke(function_name:, payload:)
+        @out.puts(result.is_a?(String) ? result : JSON.generate(result))
+        0
+      end
+
       def help
         @out.puts <<~HELP
           lambda-microvms #{VERSION}
@@ -91,6 +119,9 @@ module Lambda
             package       Create deployable source artifact
             deploy        Package, upload to S3, and create a MicroVM image
             run           Run the configured MicroVM image
+            sdk-contract  Check whether aws-sdk-lambda exposes MicroVM operations
+            function-invoke NAME [JSON]
+                          Invoke a standard Lambda function with supported AWS APIs
             version       Print version
         HELP
         0

data/lib/lambda/microvms/adapters/microvm_sdk.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module Lambda
+  module MicroVMs
+    # Internal adapter implementations for provider-specific SDK surfaces.
+    module Adapters
+      # Adapter for the experimental Lambda MicroVM SDK operation surface.
+      class MicroVMSdk
+        # SDK method names required by the experimental MicroVM lifecycle wrapper.
+        REQUIRED_OPERATIONS = %i[
+          create_microvm_image
+          get_microvm_image
+          delete_microvm_image
+          run_microvm
+          get_microvm
+          list_microvms
+          suspend_microvm
+          resume_microvm
+          terminate_microvm
+          create_microvm_auth_token
+        ].freeze
+
+        attr_reader :sdk
+
+        def initialize(sdk)
+          @sdk = sdk
+        end
+
+        # Return MicroVM SDK operations missing from the wrapped SDK client.
+        #
+        # @return [Array<Symbol>] missing SDK operation names
+        def unsupported_operations
+          REQUIRED_OPERATIONS.reject { |operation| sdk.respond_to?(operation) }
+        end
+
+        # Check whether the wrapped SDK client exposes all MicroVM operations.
+        #
+        # @return [Boolean]
+        def supported?
+          unsupported_operations.empty?
+        end
+
+        # Dispatch a MicroVM operation to the wrapped SDK client.
+        #
+        # @param operation [Symbol] SDK method name
+        # @param params [Hash] SDK request parameters
+        # @return [Object] raw SDK response
+        # @raise [UnsupportedOperationError] when the SDK does not expose the operation
+        def call(operation, **params)
+          unless sdk.respond_to?(operation)
+            raise UnsupportedOperationError, "Aws::Lambda::Client does not expose ##{operation}; run sdk-contract"
+          end
+
+          sdk.public_send(operation, **params)
+        end
+      end
+    end
+  end
+end

data/lib/lambda/microvms/client.rb

@@ -10,72 +10,145 @@ module Lambda
   module MicroVMs
     # Ruby wrapper over Aws::Lambda::Client for Lambda MicroVM lifecycle operations.
     class Client
-      attr_reader :sdk
+      # SDK methods this wrapper expects from Aws::Lambda::Client.
+      REQUIRED_OPERATIONS = Adapters::MicroVMSdk::REQUIRED_OPERATIONS
 
-      def initialize(region: nil, profile: nil, sdk: nil, **)
-        @sdk = sdk || build_sdk(region:, profile:, **)
+      attr_reader :sdk, :adapter
+
+      def initialize(region: nil, profile: nil, sdk: nil, adapter: nil, **)
+        @sdk = sdk || build_sdk(region: region, profile: profile, **)
+        @adapter = adapter || Adapters::MicroVMSdk.new(@sdk)
+      end
+
+      # Return wrapper operations missing from the given SDK client.
+      #
+      # @param sdk [Object, nil] SDK client to inspect
+      # @return [Array<Symbol>] missing SDK operation names
+      def self.unsupported_operations(sdk = nil)
+        sdk ||= Aws::Lambda::Client.new(stub_responses: true) if defined?(Aws::Lambda::Client)
+        return REQUIRED_OPERATIONS unless sdk
+
+        Adapters::MicroVMSdk.new(sdk).unsupported_operations
       end
 
+      # Check whether the given SDK client exposes all MicroVM operations.
+      #
+      # @param sdk [Object, nil] SDK client to inspect
+      # @return [Boolean]
+      def self.sdk_contract_supported?(sdk = nil)
+        unsupported_operations(sdk).empty?
+      end
+
+      # Build an image resource wrapper without fetching it.
+      #
+      # @param arn [String] MicroVM image ARN
+      # @return [Image] image resource wrapper
       def image(arn)
         Image.new(client: self, arn: arn)
       end
 
+      # Build a MicroVM resource wrapper without fetching it.
+      #
+      # @param id_or_arn [String] MicroVM id or ARN
+      # @return [MicroVM] MicroVM resource wrapper
       def microvm(id_or_arn)
         MicroVM.new(client: self, id: id_or_arn)
       end
 
+      # Create a MicroVM image through the Lambda SDK.
+      #
+      # @param params [Hash] SDK request parameters
+      # @return [Image] created image resource
       def create_image(**params)
         response = call_sdk(:create_microvm_image, **params)
         Image.from_response(client: self, response: response)
       end
 
+      # Fetch a MicroVM image and wrap the SDK response.
+      #
+      # @param params [Hash] SDK request parameters
+      # @return [Image] fetched image resource
       def get_image(**params)
         response = call_sdk(:get_microvm_image, **params)
         Image.from_response(client: self, response: response)
       end
 
+      # Delete a MicroVM image.
+      #
+      # @param params [Hash] SDK request parameters
+      # @return [Object] raw SDK response
       def delete_image(**params)
         call_sdk(:delete_microvm_image, **params)
       end
 
+      # Run a MicroVM from an image.
+      #
+      # @param params [Hash] SDK request parameters
+      # @return [MicroVM] started MicroVM resource
       def run(**params)
         response = call_sdk(:run_microvm, **params)
         MicroVM.from_response(client: self, response: response)
       end
       alias run_microvm run
 
+      # Fetch a MicroVM and wrap the SDK response.
+      #
+      # @param params [Hash] SDK request parameters
+      # @return [MicroVM] fetched MicroVM resource
       def get_microvm(**params)
         response = call_sdk(:get_microvm, **params)
         MicroVM.from_response(client: self, response: response)
       end
 
+      # List MicroVMs using the underlying Lambda SDK client.
+      #
+      # @param params [Hash] SDK request parameters
+      # @return [Object] raw SDK response
       def list_microvms(**params)
         call_sdk(:list_microvms, **params)
       end
 
+      # Suspend a MicroVM.
+      #
+      # @param params [Hash] SDK request parameters
+      # @return [Object] raw SDK response
       def suspend_microvm(**params)
         call_sdk(:suspend_microvm, **params)
       end
 
+      # Resume a suspended MicroVM.
+      #
+      # @param params [Hash] SDK request parameters
+      # @return [Object] raw SDK response
       def resume_microvm(**params)
         call_sdk(:resume_microvm, **params)
       end
 
+      # Terminate a MicroVM.
+      #
+      # @param params [Hash] SDK request parameters
+      # @return [Object] raw SDK response
       def terminate_microvm(**params)
         call_sdk(:terminate_microvm, **params)
       end
 
+      # Create an auth token for direct MicroVM endpoint access.
+      #
+      # @param params [Hash] SDK request parameters
+      # @return [Object] raw SDK response
       def create_auth_token(**params)
         call_sdk(:create_microvm_auth_token, **params)
       end
       alias create_microvm_auth_token create_auth_token
 
+      # Dispatch a supported operation to the underlying SDK client.
+      #
+      # @param operation [Symbol] SDK method name
+      # @param params [Hash] SDK request parameters
+      # @return [Object] raw SDK response
+      # @raise [UnsupportedOperationError] when the SDK does not expose the operation
       def call_sdk(operation, **params)
-        unless @sdk.respond_to?(operation)
-          raise UnsupportedOperationError, "Aws::Lambda::Client does not expose ##{operation}; upgrade aws-sdk-lambda"
-        end
-
-        @sdk.public_send(operation, **params)
+        adapter.call(operation, **params)
       end
 
       private

data/lib/lambda/microvms/deployer.rb

@@ -15,29 +15,44 @@ module Lambda
       attr_reader :project, :client, :s3
 
       def initialize(project:, client: nil, s3: nil) # rubocop:disable Naming/MethodParameterName
-        @project = project
+        @project = project.validate!
         @client = client || Client.new(region: project.region, profile: project.profile)
         @s3 = s3 || build_s3
       end
 
+      # Package the project into a deployable zip artifact.
+      #
+      # @return [String] artifact path
       def package
         Packager.new(project).package
       end
 
+      # Upload an artifact to the configured S3 bucket and prefix.
+      #
+      # @param path [String] local artifact path
+      # @return [String] S3 URI
       def upload(path)
         bucket = project.require!('deployment.bucket', project.s3_bucket)
         key = [project.s3_prefix.sub(%r{/\z}, ''), File.basename(path)].join('/')
-        s3.put_object(bucket: bucket, key: key, body: File.open(path, 'rb'))
+        File.open(path, 'rb') { |body| s3.put_object(bucket: bucket, key: key, body: body) }
         "s3://#{bucket}/#{key}"
       end
 
+      # Package, upload, and create a MicroVM image.
+      #
+      # @return [Image] created image resource
       def deploy
+        ensure_microvm_contract!
         artifact = package
         artifact_uri = upload(artifact)
         client.create_image(**project.create_image_params(artifact_uri: artifact_uri))
       end
 
+      # Run the configured image with configured runtime parameters.
+      #
+      # @return [MicroVM] started MicroVM resource
       def run
+        ensure_microvm_contract!
         image_arn = project.require!('image.arn', project.image_arn)
         role_arn = project.require!('role_arn', project.role_arn)
         client.image(image_arn).run(**project.run_params, role_arn: role_arn)
@@ -48,11 +63,18 @@ module Lambda
       def build_s3
         raise LoadError, 'install aws-sdk-s3 to use deployment helpers' unless defined?(Aws::S3::Client)
 
-        args = {}
-        args[:region] = project.region if project.region
-        args[:profile] = project.profile if project.profile
+        args = { region: project.region, profile: project.profile }.compact
         Aws::S3::Client.new(**args)
       end
+
+      def ensure_microvm_contract!
+        return unless client.respond_to?(:adapter)
+
+        missing = client.adapter.unsupported_operations
+        return if missing.empty?
+
+        raise UnsupportedOperationError, "Aws::Lambda::Client is missing MicroVM operations: #{missing.join(', ')}"
+      end
     end
   end
 end

data/lib/lambda/microvms/doctor.rb

@@ -5,6 +5,7 @@ module Lambda
   module MicroVMs
     # Performs lightweight local project readiness checks.
     class Doctor
+      # Result object for a single doctor check.
       Check = Struct.new(:name, :ok, :detail, keyword_init: true)
 
       attr_reader :project, :runner
@@ -14,6 +15,9 @@ module Lambda
         @runner = runner
       end
 
+      # Run all local readiness checks.
+      #
+      # @return [Array<Check>] check results
       def checks
         [
           check('Ruby', RUBY_VERSION >= '3.2', RUBY_VERSION),
@@ -23,7 +27,8 @@ module Lambda
           file_check('Dockerfile', project.dockerfile),
           config_check('role_arn', project.role_arn),
           config_check('deployment.bucket', project.s3_bucket),
-          ric_check
+          ric_check,
+          sdk_contract_check
         ]
       end
 
@@ -49,7 +54,8 @@ module Lambda
       end
 
       def config_check(name, value)
-        Check.new(name:, ok: value && value != '', detail: value || 'missing')
+        ok = value && value.to_s.strip != ''
+        Check.new(name:, ok: ok, detail: ok ? value : 'missing')
       end
 
       def ric_check
@@ -57,6 +63,13 @@ module Lambda
         ok = File.exist?(gemfile) && File.read(gemfile).include?('aws_lambda_ric')
         Check.new(name: 'aws_lambda_ric', ok: ok, detail: ok ? 'present in Gemfile' : 'missing from Gemfile')
       end
+
+      def sdk_contract_check
+        missing = Client.unsupported_operations
+        ok = missing.empty?
+        detail = ok ? 'MicroVM operations available' : "missing: #{missing.join(', ')}"
+        Check.new(name: 'aws-sdk-lambda MicroVM contract', ok: ok, detail: detail)
+      end
     end
   end
 end

data/lib/lambda/microvms/endpoint.rb

@@ -16,17 +16,39 @@ module Lambda
         @http = http
       end
 
+      # Send an authenticated GET request to the MicroVM endpoint.
+      #
+      # @param path [String] endpoint path
+      # @param headers [Hash] additional HTTP headers
+      # @return [Hash,String,nil] parsed JSON response or raw body
       def get(path, headers: {})
         request(Net::HTTP::Get, path, headers:)
       end
 
+      # Send an authenticated POST request to the MicroVM endpoint.
+      #
+      # @param path [String] endpoint path
+      # @param json [Hash,Array,nil] JSON body to encode
+      # @param body [String,nil] raw request body
+      # @param headers [Hash] additional HTTP headers
+      # @return [Hash,String,nil] parsed JSON response or raw body
       def post(path, json: nil, body: nil, headers: {})
         request(Net::HTTP::Post, path, json:, body:, headers:)
       end
 
+      # Build and execute an authenticated HTTP request.
+      #
+      # @param klass [Class] Net::HTTP request class
+      # @param path [String] endpoint path
+      # @param json [Hash,Array,nil] JSON body to encode
+      # @param body [String,nil] raw request body
+      # @param headers [Hash] additional HTTP headers
+      # @return [Hash,String,nil] parsed JSON response or raw body
+      # @raise [EndpointError] when the endpoint returns a non-2xx status
       def request(klass, path, json: nil, body: nil, headers: {})
-        response = @http.start(uri.host, uri.port, use_ssl: uri.scheme == 'https') do |http|
-          http.request(build_request(klass, path, headers:, body:, json:))
+        req = build_request(klass, path, headers:, body:, json:)
+        response = @http.start(req.uri.host, req.uri.port, use_ssl: req.uri.scheme == 'https') do |http|
+          http.request(req)
         end
 
         success = response.code.to_i.between?(200, 299)
@@ -41,10 +63,10 @@ module Lambda
       private
 
       def build_uri(path)
-        base = URI(@url)
+        base = ::URI.parse(@url)
         return base if path.nil? || path.empty? || path == '/'
 
-        joined = [base.path.sub(%r{/\z}, ''), path.sub(%r{\A/}, '')].reject(&:empty?).join('/')
+        joined = [base.path.sub(%r{/\z}, ''), path.sub(%r{\A/}, '')].reject(&:empty?).join('/').sub(%r{\A/+}, '')
         base.path = "/#{joined}"
         base
       end

data/lib/lambda/microvms/function_client.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+require 'json'
+
+module Lambda
+  module MicroVMs
+    # Thin wrapper over stable Aws::Lambda::Client function APIs.
+    class FunctionClient
+      attr_reader :sdk
+
+      def initialize(region: nil, profile: nil, sdk: nil, **)
+        @sdk = sdk || build_sdk(region: region, profile: profile, **)
+      end
+
+      # Create a Lambda function from a zip file using supported AWS APIs.
+      #
+      # @param name [String] function name
+      # @param role_arn [String] IAM role ARN
+      # @param handler [String] handler name
+      # @param runtime [String] Lambda runtime identifier
+      # @param zip_file [String] path to deployment zip
+      # @param params [Hash] additional create_function parameters
+      # @return [Object] raw SDK response
+      def create_function(name:, role_arn:, handler:, runtime:, zip_file:, **params) # rubocop:disable Metrics/ParameterLists
+        sdk.create_function(
+          **params,
+          function_name: name,
+          role: role_arn,
+          handler: handler,
+          runtime: runtime,
+          code: { zip_file: File.binread(zip_file) }
+        )
+      end
+
+      # Update Lambda function code from a zip file.
+      #
+      # @param function_name [String] function name or ARN
+      # @param zip_file [String] path to deployment zip
+      # @param params [Hash] additional update_function_code parameters
+      # @return [Object] raw SDK response
+      def update_function_code(function_name:, zip_file:, **params)
+        sdk.update_function_code(**params, function_name: function_name, zip_file: File.binread(zip_file))
+      end
+
+      # Invoke a Lambda function and parse JSON payloads when possible.
+      #
+      # @param function_name [String] function name or ARN
+      # @param payload [Object] request payload
+      # @param params [Hash] additional invoke parameters
+      # @return [Object] parsed response payload or raw response body
+      def invoke(function_name:, payload: nil, **params)
+        response = sdk.invoke(**params, function_name: function_name, payload: encode_payload(payload))
+        parse_payload(response.payload)
+      end
+
+      private
+
+      def build_sdk(region:, profile:, **options)
+        unless defined?(Aws::Lambda::Client)
+          raise LoadError, 'install aws-sdk-lambda to use Lambda::MicroVMs::FunctionClient'
+        end
+
+        args = options.dup
+        args[:region] = region if region
+        args[:profile] = profile if profile
+        Aws::Lambda::Client.new(**args)
+      end
+
+      def encode_payload(payload)
+        case payload
+        when nil
+          nil
+        when String
+          payload
+        else
+          JSON.generate(payload)
+        end
+      end
+
+      def parse_payload(payload)
+        body = payload.respond_to?(:read) ? payload.read : payload.to_s
+        return nil if body.empty?
+
+        JSON.parse(body)
+      rescue JSON::ParserError
+        body
+      end
+    end
+  end
+end