clear-skies-aws 2.0.11__py3-none-any.whl → 2.0.12__py3-none-any.whl

{clear_skies_aws-2.0.11.dist-info → clear_skies_aws-2.0.12.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: clear-skies-aws
-Version: 2.0.11
+Version: 2.0.12
 Summary: clearskies bindings for working in AWS
 Project-URL: Repository, https://github.com/clearskies-py/clearskies-aws
 Project-URL: Issues, https://github.com/clearskies-py/clearskies-aws/issues
@@ -17,7 +17,7 @@ Classifier: Programming Language :: Python :: 3
 Requires-Python: <4.0,>=3.11
 Requires-Dist: awslambdaric>=3.1.1
 Requires-Dist: boto3<2.0.0,>=1.26.148
-Requires-Dist: clear-skies<3.0.0,>=2.0.20
+Requires-Dist: clear-skies<3.0.0,>=2.0.37
 Requires-Dist: jinja2>=3.1.6
 Requires-Dist: types-boto3[dynamodb,secretsmanager,ses,sns,sqs,ssm,stepfunctions]<2.0.0,>=1.38.13
 Provides-Extra: akeyless

{clear_skies_aws-2.0.11.dist-info → clear_skies_aws-2.0.12.dist-info}/RECORD

@@ -7,13 +7,13 @@ clearskies_aws/actions/sns.py,sha256=YS1TbEwtU-0lDbjG2HyTBs2J-ML5OL3ModAiGTMeK-c
 clearskies_aws/actions/sqs.py,sha256=r0z8njU87n09UgAq3l34JuNIbaBE85D_z8IE6ciIs9Q,3359
 clearskies_aws/actions/step_function.py,sha256=Y6tGbQJIAD_IwV9ohwYfuv3vqtryTwpFTNGUFgdj_DQ,2689
 clearskies_aws/backends/__init__.py,sha256=lmjWPoLN7Ebmdj3Pv5X1tJDcRWN3PsR8aGG9nDcqOrs,635
-clearskies_aws/backends/backend.py,sha256=WpsoT0pZOdilvtOkbiNtk6DoOEzmjyWcCDfUCWOlToc,4316
+clearskies_aws/backends/backend.py,sha256=uxGlThqp2vbCcvQPimFwwPKaF0oqHAjmTgymmjOoTqc,4224
 clearskies_aws/backends/dynamo_db_backend.py,sha256=0KfAow5pUXpiBg0rRWtG3j48mpHUtJP9q-C2FfpBeqA,29411
 clearskies_aws/backends/dynamo_db_condition_parser.py,sha256=796BhrqqZy_lW4wVYbDKK85oVVKa0YnWbtl4Bb0RNF0,12637
 clearskies_aws/backends/dynamo_db_parti_ql_backend.py,sha256=p0SdrRq467w0w5OxYscxPfqUOjrkZ41JLmJa3KQCXq8,46097
-clearskies_aws/backends/sqs_backend.py,sha256=kHTzgBwpYzV31UcGaoSUcC_7eZEwm-GsCHvXFM1OLT0,2152
+clearskies_aws/backends/sqs_backend.py,sha256=uOGi8UeqBsReTDdaCA2X-V4lo4pXpyTsaz1WHHetPYQ,2238
 clearskies_aws/configs/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-clearskies_aws/contexts/__init__.py,sha256=kBLUlkpIp88n5RgbE9gVi4rDnJou81vCE5g_aiv2v8Y,717
+clearskies_aws/contexts/__init__.py,sha256=kHru0DK5wpu8Lgx2umVPwqQz5rYRvA50Brnw8HxPgfU,819
 clearskies_aws/contexts/cli_web_socket_mock.py,sha256=XjsFcx0YlQqjb9Hh8q2NUW7T2Exu7_FHx9v_Am0Uq0g,784
 clearskies_aws/contexts/lambda_alb.py,sha256=QvVlBPL1bi_fCYEpq84tGWAfLktu8lm_Atqd6pb_ksw,3496
 clearskies_aws/contexts/lambda_api_gateway.py,sha256=e4g3RNc9rdQndxlyGh7VV1Sh6RROgbWei1lxOzGPB5k,3424
@@ -21,6 +21,7 @@ clearskies_aws/contexts/lambda_api_gateway_web_socket.py,sha256=G84U8KvLWx9W_J11
 clearskies_aws/contexts/lambda_invoke.py,sha256=TBu-SqZyBiXDOz_vrKiR1Kdg0HoVZ-8xhXDOti-SBr0,4942
 clearskies_aws/contexts/lambda_sns.py,sha256=wxrT6bOCp2T8aUmmOhVcTiZ6MXkoGUrjCspsu7XiK8E,4213
 clearskies_aws/contexts/lambda_sqs_standard.py,sha256=S6bdSshZeKpssHcNXpxaOEWU_jw7LBA78H9d8Mwdy3o,5363
+clearskies_aws/contexts/lambda_step_function.py,sha256=pgDuaFuyWQOLJRgXIL2axCsT-zFRcGBjDJpZJ-ojxvo,4334
 clearskies_aws/cursors/__init__.py,sha256=vy-WYxNEy5nd9fqY0En3T6WhE3omoV1tE-A5Uz26cCk,94
 clearskies_aws/cursors/iam/__init__.py,sha256=dY410gfPoMXB42jhmamqD5IiCeopDnxr5wIibpqaYcY,127
 clearskies_aws/cursors/iam/rds_mysql.py,sha256=bdAYTLg9t8DsoSi0otY9bmIgLCbrezczxd_3hWuEkeE,5639
@@ -35,7 +36,7 @@ clearskies_aws/di/inject/parameter_store.py,sha256=g0uAVwQEywLO9bCcYLbDKuyYnYgVy
 clearskies_aws/endpoints/__init__.py,sha256=OUL_nhtuNs62BvQeVtC9xP_e9Hs_-qjANvb81vdLdrc,61
 clearskies_aws/endpoints/secrets_manager_rotation.py,sha256=c__4N-Z4qZ9XkzMMyIcxyPjOIxdO801FAJp6oX6n0a4,7761
 clearskies_aws/endpoints/simple_body_routing.py,sha256=B3fnfxUEMuNpzc26Pzly6618DFU9fpaCk8KhTGSaptE,1181
-clearskies_aws/input_outputs/__init__.py,sha256=RTDFwhPWZ2S0tZQiIPH0Tkj2xF-9qBjZte_CA2cmGt8,743
+clearskies_aws/input_outputs/__init__.py,sha256=M7eVt-sqwXYOS5atXbWjQTp3FogrhTcg6c5hH_9GrJo,850
 clearskies_aws/input_outputs/cli_web_socket_mock.py,sha256=cp0MaJjVnsXE1rx5K44lpN9uHKo3MOAsNxVQ3AsJOi4,547
 clearskies_aws/input_outputs/lambda_alb.py,sha256=K298vSqqXzTR1luWRi5lwFL_EvzrIku1wHv8og23ulw,2083
 clearskies_aws/input_outputs/lambda_api_gateway.py,sha256=OeXgjAUMKnURnkgcqTgiZE8zRFfOdDrRxLCCv1gvvsA,4742
@@ -44,6 +45,7 @@ clearskies_aws/input_outputs/lambda_input_output.py,sha256=bKzMXmvRajl0RBOGmXASr
 clearskies_aws/input_outputs/lambda_invoke.py,sha256=R6QLTSsNkdnxMegq___5oK_BV1u6s76MhdJAO-ifKEU,2854
 clearskies_aws/input_outputs/lambda_sns.py,sha256=Tsm4PtVLfmlZ6SCY0tGpsRlXJ-3ZWTu_Gh7QL6ir9gc,3050
 clearskies_aws/input_outputs/lambda_sqs_standard.py,sha256=RPWO6vvWENAny94KQvKJmF17RtNr-ihTcqnRCz-oq4U,2911
+clearskies_aws/input_outputs/lambda_step_function.py,sha256=CfLy3lwNCGrtNO2b0KOoWwh8zy4gl2Id8Q1ZuLIobKo,8405
 clearskies_aws/mocks/__init__.py,sha256=mn764gINN667tYoJfnsM6HjAAhCsO_kZ6E-fUwdLY50,22
 clearskies_aws/mocks/actions/__init__.py,sha256=to1r8B365Et2PRVfUWWnJGt7Hdr8vwwQuNyZvTSTP6g,152
 clearskies_aws/mocks/actions/ses.py,sha256=KsII9ggU364BQoxgHfO2rxi6tjVsdnwJyMhtclOhWLQ,998
@@ -62,7 +64,7 @@ clearskies_aws/secrets/additional_configs/iam_db_auth.py,sha256=PwyiLaacpRfhBKzQ
 clearskies_aws/secrets/additional_configs/iam_db_auth_with_ssm.py,sha256=ABY29X-YvrE6vvNo6kVdf4DqyRNq5cFR5SfK7MNkltE,3463
 clearskies_aws/secrets/additional_configs/mysql_connection_dynamic_producer_via_ssh_cert_bastion.py,sha256=mLaplwvJLSbGh6oXgdOKL9Mv-6hLv5OUYCfEwHbHvLE,3700
 clearskies_aws/secrets/additional_configs/mysql_connection_dynamic_producer_via_ssm_bastion.py,sha256=2VHOwto4I9gBwrpd2HGpL-Wr0T2S-jFjUhe2Ib8hNJ8,6596
-clear_skies_aws-2.0.11.dist-info/METADATA,sha256=sHHGa57BEMydO5oT9JSeqZPffwvdk3v7hSgXdeIBqu0,9077
-clear_skies_aws-2.0.11.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-clear_skies_aws-2.0.11.dist-info/licenses/LICENSE,sha256=MkEX8JF8kZxdyBpTTcB0YTd-xZpWnHvbRlw-pQh8u58,1069
-clear_skies_aws-2.0.11.dist-info/RECORD,,
+clear_skies_aws-2.0.12.dist-info/METADATA,sha256=Peh_b5gfQkU62yNOdIGRsPWVpVXsyGS0YeQGKZgcWe8,9077
+clear_skies_aws-2.0.12.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+clear_skies_aws-2.0.12.dist-info/licenses/LICENSE,sha256=MkEX8JF8kZxdyBpTTcB0YTd-xZpWnHvbRlw-pQh8u58,1069
+clear_skies_aws-2.0.12.dist-info/RECORD,,

clearskies_aws/backends/backend.py

@@ -7,6 +7,12 @@ import clearskies.model
 import clearskies.query
 from clearskies.autodoc.schema import Schema as AutoDocSchema
 from clearskies.di import inject
+from clearskies.query.result import (
+    CountQueryResult,
+    RecordQueryResult,
+    RecordsQueryResult,
+    SuccessQueryResult,
+)
 
 from clearskies_aws.di.inject import boto3
 
@@ -31,35 +37,25 @@ class Backend(clearskies.Configurable, clearskies.backends.Backend, clearskies.d
     boto3 = boto3.Boto3()
     environment = inject.Environment()
 
-    def update(self, id: int | str, data: dict[str, Any], model: clearskies.model.Model) -> dict[str, Any]:
+    def update(self, id: int | str, data: dict[str, Any], model: clearskies.model.Model) -> RecordQueryResult:
         """Update the record with the given id with the information from the data dictionary."""
-        return {}
+        return RecordQueryResult(record={})
 
-    def create(self, data: dict[str, Any], model: clearskies.model.Model) -> dict[str, Any]:
+    def create(self, data: dict[str, Any], model: clearskies.model.Model) -> RecordQueryResult:
         """Create a record with the information from the data dictionary."""
-        return {}
+        return RecordQueryResult(record={})
 
-    def delete(self, id: int | str, model: clearskies.model.Model) -> bool:
+    def delete(self, id: int | str, model: clearskies.model.Model) -> SuccessQueryResult:
         """Delete the record with the given id."""
-        return True
+        return SuccessQueryResult()
 
-    def count(self, query: clearskies.query.Query) -> int:
+    def count(self, query: clearskies.query.Query) -> CountQueryResult:
         """Return the number of records which match the given query configuration."""
-        return 1
-
-    def records(
-        self,
-        query: clearskies.query.Query,
-        next_page_data: dict[str, str | int] | None = None,
-    ) -> list[dict[str, Any]]:
-        """
-        Return a list of records that match the given query configuration.
+        return CountQueryResult(count=1)
 
-        next_page_data is used to return data to the caller.  Pass in an empty dictionary, and it will be populated
-        with the data needed to return the next page of results.  If it is still an empty dictionary when returned,
-        then there is no additional data.
-        """
-        return []
+    def records(self, query: clearskies.query.Query) -> RecordsQueryResult:
+        """Return a list of records that match the given query configuration."""
+        return RecordsQueryResult(records=[])
 
     def validate_pagination_data(self, data: dict[str, Any], case_mapping: Callable[[str], str]) -> str:
         """

clearskies_aws/backends/sqs_backend.py

@@ -5,6 +5,7 @@ from typing import Any
 
 from clearskies import Model
 from clearskies.query import Query
+from clearskies.query.result import CountQueryResult, RecordQueryResult, RecordsQueryResult, SuccessQueryResult
 from types_boto3_sqs import SQSClient
 
 from clearskies_aws.backends import backend
@@ -37,25 +38,21 @@ class SqsBackend(backend.Backend):
 
         return self._sqs
 
-    def create(self, data: dict[str, Any], model: Model) -> dict[str, Any]:
+    def create(self, data: dict[str, Any], model: Model) -> RecordQueryResult:
         self.sqs.send_message(
             QueueUrl=model.destination_name(),
             MessageBody=json.dumps(data),
         )
-        return {**data}
+        return RecordQueryResult(record={**data})
 
-    def update(self, id: int | str, data: dict[str, Any], model: Model) -> dict[str, Any]:
+    def update(self, id: int | str, data: dict[str, Any], model: Model) -> RecordQueryResult:
         raise ValueError("The SQS backend only supports the create operation")
 
-    def delete(self, id: int | str, model: Model) -> bool:
+    def delete(self, id: int | str, model: Model) -> SuccessQueryResult:
         raise ValueError("The SQS backend only supports the create operation")
 
-    def count(self, query: Query) -> int:
+    def count(self, query: Query) -> CountQueryResult:
         raise ValueError("The SQS backend only supports the create operation")
 
-    def records(
-        self,
-        query: Query,
-        next_page_data: dict[str, str | int] | None = None,
-    ) -> list[dict[str, Any]]:
+    def records(self, query: Query) -> RecordsQueryResult:
         raise ValueError("The SQS backend only supports the create operation")

clearskies_aws/contexts/__init__.py

@@ -11,6 +11,7 @@ from clearskies_aws.contexts.lambda_sns import LambdaSns
 from clearskies_aws.contexts.lambda_sqs_standard import (
     LambdaSqsStandard,
 )
+from clearskies_aws.contexts.lambda_step_function import LambdaStepFunction
 
 __all__ = [
     "CliWebSocketMock",
@@ -20,4 +21,5 @@ __all__ = [
     "LambdaInvoke",
     "LambdaSns",
     "LambdaSqsStandard",
+    "LambdaStepFunction",
 ]

clearskies_aws/contexts/lambda_step_function.py

@@ -0,0 +1,129 @@
+from __future__ import annotations
+
+from typing import Any, Callable
+
+from clearskies.contexts.context import Context
+
+from clearskies_aws.input_outputs.lambda_step_function import LambdaStepFunction as LambdaStepFunctionInputOutput
+
+
+class LambdaStepFunction(Context):
+    """
+    Execute a Lambda invoked from AWS Step Functions.
+
+    This context is used when your clearskies application is running in a Lambda that is
+    invoked from an AWS Step Functions state machine. It supports extracting variables
+    assigned in the Step Functions state and exposing them through the clearskies
+    Environment class.
+
+    ### Usage
+
+    Basic usage:
+
+    ```python
+    import clearskies
+    import clearskies_aws
+
+
+    def my_function(request_data, environment):
+        # Access extracted environment variables
+        business_name = environment.get("BUSINESS_NAME")
+        return {"business": business_name, "data": request_data}
+
+
+    lambda_step_function = clearskies_aws.contexts.LambdaStepFunction(
+        clearskies.endpoints.Callable(
+            my_function,
+            return_standard_response=False,
+        ),
+        environment_keys=["BUSINESS_NAME", "GITLAB_AUTH_KEY"],
+    )
+
+
+    def lambda_handler(event, context):
+        return lambda_step_function(event, context)
+    ```
+
+    ### Configuration Options
+
+    The `environment_keys` parameter accepts three types:
+
+    **1. List of keys** - Extract specific keys from the event:
+    ```python
+    clearskies_aws.contexts.LambdaStepFunction(
+        endpoint, environment_keys=["BUSINESS_NAME", "GITLAB_AUTH_KEY"]
+    )
+    ```
+
+    **2. Mapping dict** - Map event keys to environment variable names:
+    ```python
+    clearskies_aws.contexts.LambdaStepFunction(
+        endpoint,
+        environment_keys={
+            "BUSINESS_NAME": "BUSINESS_NAME",  # same name
+            "GITLAB_AUTH_KEY": "GITLAB_TOKEN_PATH",  # rename
+        },
+    )
+    ```
+
+    **3. Callable** - Full control via a function (supports dependency injection):
+    ```python
+    def extract_env_vars(event, secrets):
+        # Can inject clearskies dependencies like secrets
+        return {
+            "BUSINESS_NAME": event.get("BUSINESS_NAME"),
+            "GITLAB_KEY": secrets.get(event.get("GITLAB_AUTH_KEY")),
+        }
+
+
+    clearskies_aws.contexts.LambdaStepFunction(endpoint, environment_keys=extract_env_vars)
+    ```
+
+    ### Context Specifics
+
+    When using this context, the following named parameters become available to inject
+    into any callable invoked by clearskies:
+
+    |         Name           |        Type        |           Description                |
+    |:----------------------:|:------------------:|:------------------------------------:|
+    |        `event`         |  `dict[str, Any]`  | The lambda `event` object            |
+    |       `context`        |  `dict[str, Any]`  | The lambda `context` object          |
+    |   `invocation_type`    |       `str`        | Always `"step-functions"`            |
+    |    `function_name`     |       `str`        | The name of the lambda function      |
+    |   `function_version`   |       `str`        | The function version                 |
+    |      `request_id`      |       `str`        | The AWS request id for the call      |
+    |    `states_context`    |  `dict[str, Any]`  | The Step Functions $states context   |
+
+    """
+
+    def __init__(
+        self,
+        endpoint,
+        environment_keys: list[str] | dict[str, str] | Callable[..., dict[str, Any]] | None = None,
+        **kwargs,
+    ):
+        super().__init__(endpoint, **kwargs)
+        self._environment_keys = environment_keys
+
+    def __call__(  # type: ignore[override]
+        self,
+        event: dict[str, Any],
+        context: dict[str, Any],
+        request_method: str = "",
+        url: str = "",
+    ) -> dict[str, Any]:
+        input_output = LambdaStepFunctionInputOutput(
+            event,
+            context,
+            request_method=request_method,
+            url=url,
+            environment_keys=self._environment_keys,
+        )
+
+        # Inject extra environment variables from the step function event
+        input_output.inject_extra_environment_variables(
+            self.di.build("environment", cache=True),
+            self.di,
+        )
+
+        return self.execute_application(input_output)

clearskies_aws/input_outputs/__init__.py

@@ -9,6 +9,7 @@ from clearskies_aws.input_outputs.lambda_api_gateway_web_socket import (
 from clearskies_aws.input_outputs.lambda_invoke import LambdaInvoke
 from clearskies_aws.input_outputs.lambda_sns import LambdaSns
 from clearskies_aws.input_outputs.lambda_sqs_standard import LambdaSqsStandard
+from clearskies_aws.input_outputs.lambda_step_function import LambdaStepFunction
 
 __all__ = [
     "CliWebSocketMock",
@@ -18,4 +19,5 @@ __all__ = [
     "LambdaInvoke",
     "LambdaSns",
     "LambdaSqsStandard",
+    "LambdaStepFunction",
 ]

clearskies_aws/input_outputs/lambda_step_function.py

@@ -0,0 +1,208 @@
+from __future__ import annotations
+
+import json
+from typing import Any as TypingAny
+from typing import Callable
+
+from clearskies.configs import Any
+from clearskies.di import Di
+from clearskies.environment import Environment
+from clearskies.exceptions import ClientError
+from clearskies.input_outputs import Headers
+
+from clearskies_aws.input_outputs import lambda_input_output
+
+
+class LambdaStepFunction(lambda_input_output.LambdaInputOutput):
+    """
+    Input/output handler for Lambda invocations from AWS Step Functions.
+
+    This input/output handles Lambda invocations that come from AWS Step Functions state machines.
+    It provides support for extracting variables assigned in the Step Functions state and exposing
+    them through the clearskies Environment class.
+
+    The primary use case is when you want to use Step Functions variables (set via the `Assign` feature
+    in JSONata expressions) as environment variables in your clearskies application. This allows you to
+    reuse the same Lambda function with different configuration values passed through the state machine.
+
+    The `environment_keys` parameter controls how variables are extracted from the event and injected
+    into the environment. It accepts three types:
+
+    **List of keys** - Extract specific keys directly from the event:
+
+    ```python
+    LambdaStepFunction(event, context, environment_keys=["BUSINESS_NAME", "API_KEY"])
+    ```
+
+    **Mapping dict** - Map event keys to different environment variable names:
+
+    ```python
+    LambdaStepFunction(
+        event,
+        context,
+        environment_keys={
+            "BUSINESS_NAME": "COMPANY_NAME",  # event["BUSINESS_NAME"] -> env["COMPANY_NAME"]
+            "GITLAB_AUTH_KEY": "GITLAB_TOKEN_PATH",
+        },
+    )
+    ```
+
+    **Callable** - Full control via a function that can use dependency injection:
+
+    ```python
+    def extract_env_vars(event, secrets):
+        # Can inject clearskies dependencies like secrets
+        return {
+            "BUSINESS_NAME": event.get("BUSINESS_NAME"),
+            "GITLAB_KEY": secrets.get(event.get("GITLAB_AUTH_KEY")),
+        }
+
+
+    LambdaStepFunction(event, context, environment_keys=extract_env_vars)
+    ```
+
+    Note that when using a list or dict, all specified keys must exist in the event or a `KeyError`
+    will be raised. When using a callable, it must return a dictionary or a `TypeError` will be raised.
+    """
+
+    """
+    Configuration for extracting environment variables from the Step Functions event.
+
+    Can be a list of keys to extract directly, a dict mapping event keys to environment names,
+    or a callable that receives the event and returns a dict of environment variables.
+    """
+    environment_keys = Any(default=None)
+
+    def __init__(
+        self,
+        event: dict[str, TypingAny],
+        context: dict[str, TypingAny],
+        request_method: str = "",
+        url: str = "",
+        environment_keys: list[str] | dict[str, str] | Callable[..., dict[str, TypingAny]] | None = None,
+    ):
+        super().__init__(event, context)
+
+        self.environment_keys = environment_keys
+
+        if url:
+            self.url = url
+            self.path = url
+        else:
+            self.supports_url = True
+        if request_method:
+            self.request_method = request_method.upper()
+        else:
+            self.supports_request_method = False
+
+        self.request_headers = Headers({})
+
+    def inject_extra_environment_variables(self, environment: Environment, di: Di) -> None:
+        """
+        Extract and inject environment variables from the event into the Environment.
+
+        This method is called by the context to extract variables from the Step Functions event
+        and inject them into the clearskies Environment. The extraction behavior depends on the
+        type of `environment_keys`:
+
+        - If `environment_keys` is `None`, no extraction is performed.
+        - If `environment_keys` is a list, each key is extracted from the event and injected
+          with the same name.
+        - If `environment_keys` is a dict, each event key is mapped to the corresponding
+          environment name.
+        - If `environment_keys` is a callable, it is invoked via the DI container (allowing
+          dependency injection) and must return a dict of environment variables.
+
+        Raises `KeyError` if a requested key is not found in the event (for list/dict modes).
+        Raises `TypeError` if a callable does not return a dictionary.
+        """
+        if self.environment_keys is None:
+            return
+
+        extracted: dict[str, TypingAny] = {}
+
+        if callable(self.environment_keys):
+            # Let clearskies call the callable so it can inject dependencies
+            result = di.call_function(self.environment_keys, event=self.event)
+            if not isinstance(result, dict):
+                callable_name = getattr(self.environment_keys, "__name__", str(self.environment_keys))
+                raise TypeError(
+                    f"The environment_keys callable '{callable_name}' must return a dictionary, "
+                    f"but returned {type(result).__name__}"
+                )
+            extracted = result
+        elif isinstance(self.environment_keys, dict):
+            for event_key, env_name in self.environment_keys.items():
+                if event_key not in self.event:
+                    raise KeyError(
+                        f"environment_keys requested a key called `{event_key}` but this was not found in the event"
+                    )
+                extracted[env_name] = self.event[event_key]
+        elif isinstance(self.environment_keys, list):
+            for key in self.environment_keys:
+                if key not in self.event:
+                    raise KeyError(
+                        f"environment_keys requested a key called `{key}` but this was not found in the event"
+                    )
+                extracted[key] = self.event[key]
+
+        # Inject extracted values into the environment
+        for key, value in extracted.items():
+            environment.set(key, value)
+
+    def has_body(self) -> bool:
+        """Step Functions invocations always have a body (the event itself)."""
+        return True
+
+    def get_body(self) -> str:
+        """Return the entire event as a JSON-encoded string."""
+        if isinstance(self.event, (dict, list)):
+            return json.dumps(self.event)
+        return str(self.event)
+
+    def respond(self, body: TypingAny, status_code: int = 200) -> TypingAny:
+        """Return the response directly for Step Functions invocations (no HTTP wrapping)."""
+        if isinstance(body, bytes):
+            return body.decode("utf-8")
+        return body
+
+    def get_protocol(self) -> str:
+        """Return the protocol identifier for Step Functions invocations."""
+        return "step-functions"
+
+    def context_specifics(self) -> dict[str, TypingAny]:
+        """
+        Provide Step Functions specific context data for dependency injection.
+
+        Returns a dict containing:
+        - `event`: The raw Lambda event
+        - `context`: The raw Lambda context
+        - `invocation_type`: Always "step-functions"
+        - `function_name`: The Lambda function name
+        - `function_version`: The Lambda function version
+        - `request_id`: The AWS request ID
+        - `states_context`: The Step Functions $states context (if present)
+        """
+        states_context = self.event.get("$states", {})
+
+        return {
+            **super().context_specifics(),
+            "invocation_type": "step-functions",
+            "function_name": self.context.get("function_name"),
+            "function_version": self.context.get("function_version"),
+            "request_id": self.context.get("aws_request_id"),
+            "states_context": states_context,
+        }
+
+    @property
+    def request_data(self) -> dict[str, TypingAny] | list[TypingAny] | None:
+        """Return the event directly as request data."""
+        return self.event
+
+    def json_body(
+        self, required: bool = True, allow_non_json_bodies: bool = False
+    ) -> dict[str, TypingAny] | list[TypingAny] | None:
+        """Return the event as JSON data (already parsed from the Lambda invocation)."""
+        if required and not self.event:
+            raise ClientError("Request body was not valid JSON")
+        return self.event