clear-skies-aws 1.10.2__py3-none-any.whl → 2.0.2__py3-none-any.whl

clearskies_aws/di/inject/__init__.py

@@ -0,0 +1,6 @@
+from __future__ import annotations
+
+from clearskies_aws.di.inject.boto3 import Boto3
+from clearskies_aws.di.inject.boto3_session import Boto3Session
+
+__all__ = ["Boto3", "Boto3Session"]

clearskies_aws/di/inject/boto3.py

@@ -0,0 +1,15 @@
+from __future__ import annotations
+
+from types import ModuleType
+
+from clearskies.di.injectable import Injectable
+
+
+class Boto3(Injectable):
+    def __init__(self, cache: bool = True):
+        self.cache = cache
+
+    def __get__(self, instance, parent) -> ModuleType:
+        if instance is None:
+            return self  # type: ignore
+        return self._di.build_from_name("boto3", cache=self.cache)

clearskies_aws/di/inject/boto3_session.py

@@ -0,0 +1,13 @@
+from types import ModuleType
+
+from clearskies.di.injectable import Injectable
+
+
+class Boto3Session(Injectable):
+    def __init__(self, cache: bool = True):
+        self.cache = cache
+
+    def __get__(self, instance, parent) -> ModuleType:
+        if instance is None:
+            return self  # type: ignore
+        return self._di.build_from_name("boto3_session", cache=self.cache)

clearskies_aws/di/inject/parameter_store.py

@@ -0,0 +1,15 @@
+from clearskies.di.injectable import Injectable
+
+from clearskies_aws.secrets.parameter_store import (
+    ParameterStore as ParameterStoreDependency,
+)
+
+
+class ParameterStore(Injectable):
+    def __init__(self, cache: bool = True):
+        self.cache = cache
+
+    def __get__(self, instance, parent) -> ParameterStoreDependency:
+        if instance is None:
+            return self  # type: ignore
+        return self._di.build_from_name("parameter_store", cache=self.cache)

clearskies_aws/{handlers → endpoints}/secrets_manager_rotation.py

@@ -1,56 +1,70 @@
+from __future__ import annotations
+
 import json
+from collections.abc import Callable
+from typing import Any
 
-import clearskies
-from clearskies.handlers.exceptions import ClientError
-from clearskies.handlers.base import Base
 import botocore
+import clearskies
+from clearskies import Endpoint
+from clearskies.configs import Callable as CallableConfig
+from clearskies.configs import Schema as SchemaConfig
+from clearskies.configs import StringList
+from clearskies.decorators import parameters_to_properties
+from clearskies.di.inject import Di
+from clearskies.exceptions import ClientError
+from clearskies.input_outputs import InputOutput
 
-class SecretsManagerRotation(Base, clearskies.handlers.SchemaHelper):
-    _steps = ["createSecret", "setSecret", "testSecret", "finishSecret"]
+from clearskies_aws.di import inject
 
-    current = "AWSCURRENT"
-    pending = "AWSPENDING"
 
-    _configuration_defaults = {
-        "createSecret": None,
-        "setSecret": None,
-        "testSecret": None,
-        "finishSecret": None,
-        "schema": [],
-    }
+class SecretsManagerRotation(Endpoint):
 
-    def __init__(self, boto3, di):
-        super().__init__(di)
-        self.boto3 = boto3
+    di = Di()
+    boto3 = inject.Boto3()
 
-    def _check_configuration(self, configuration):
-        super()._check_configuration(configuration)
+    current = "AWSCURRENT"
+    pending = "AWSPENDING"
+
+    steps = StringList(default=["createSecret", "setSecret", "testSecret", "finishSecret"])
+    create_secret = CallableConfig(default=None)
+    set_secret = CallableConfig(default=None)
+    test_secret = CallableConfig(default=None)
+    finish_secret = CallableConfig(default=None)
+    schema = SchemaConfig(default=None)
+
+    @parameters_to_properties
+    def __init__(
+        self,
+        steps: list[str] | None,
+        create_secret: Callable | None,
+        set_secret: Callable | None,
+        test_secret: Callable | None,
+        finish_secret: Callable | None,
+        schema: list[dict] | None,
+    ):
+        super().__init__()
+
+    def configure(self):
+        self.finalize_and_validate_configuration()
         class_name = self.__class__.__name__
-        if not configuration.get("createSecret"):
+        if not self.create_secret:
             raise KeyError(f"Missing required configuration 'createSecret' for handler {class_name}")
 
-        for config_name in self._steps:
-            config = configuration.get(config_name)
+        for config_name in self.steps:
+            config = getattr(self, config_name)
             if config is None:
                 continue
-            if not callable(config):
-                raise ValueError(f"Misconfiguration for handler {class_name}: configuration '{config_name}' is not callable")
 
-        if configuration.get("schema") is not None:
-            self._check_schema(configuration["schema"], None, f"Misconfiguration for handler {class_name}")
+    def handle(self, input_output: InputOutput):
+        request_data = json.loads(input_output.get_body())
 
-    def _finalize_configuration(self, configuration):
-        if configuration.get('schema'):
-            configuration['schema'] = self._schema_to_columns(configuration['schema'])
-        return super()._finalize_configuration(configuration)
+        self.find_input_errors(request_data, input_output, self.schema)
 
-    def handle(self, input_output):
-        request_data = input_output.json_body()
-
-        arn = request_data.get('SecretId')
-        request_token = request_data.get('ClientRequestToken')
-        step = request_data.get('Step')
-        secretsmanager = self.boto3.client('secretsmanager')
+        arn = request_data.get("SecretId")
+        request_token = request_data.get("ClientRequestToken")
+        step = request_data.get("Step")
+        secretsmanager = self.boto3.client("secretsmanager")
         metadata = secretsmanager.describe_secret(SecretId=arn)
 
         self._validate_secret_and_request(step, arn, metadata, request_token)
@@ -59,7 +73,7 @@ class SecretsManagerRotation(Base, clearskies.handlers.SchemaHelper):
         pending_secret_data = {}
 
         current_secret = secretsmanager.get_secret_value(SecretId=arn, VersionStage=self.current)
-        current_secret_data = json.loads(current_secret['SecretString'])
+        current_secret_data = json.loads(current_secret["SecretString"])
 
         # validate the current secret
         secret_errors = {
@@ -72,10 +86,12 @@ class SecretsManagerRotation(Base, clearskies.handlers.SchemaHelper):
         # check for a pending secret.  Note that this is not always available.  In the event that we are retrying a failed
         # rotation it will already be set, in which case we need to skip the createSecret step.
         try:
-            pending_secret = secretsmanager.get_secret_value(SecretId=arn, VersionId=request_token, VersionStage=self.pending)
-            pending_secret_data = json.loads(pending_secret['SecretString'])
+            pending_secret = secretsmanager.get_secret_value(
+                SecretId=arn, VersionId=request_token, VersionStage=self.pending
+            )
+            pending_secret_data = json.loads(pending_secret["SecretString"])
         except botocore.exceptions.ClientError as error:
-            if error.response['Error']['Code'] == 'ResourceNotFoundException':
+            if error.response["Error"]["Code"] == "ResourceNotFoundException":
                 pending_secret_data = None
             else:
                 raise error
@@ -94,12 +110,12 @@ class SecretsManagerRotation(Base, clearskies.handlers.SchemaHelper):
             arn=arn,
         )
 
-    def _validate_secret_and_request(self, step, arn, metadata, request_token):
-        """ This function does some basic checks suggested by AWS of both the request and the secret to make sure everything is on the up-and-up. """
-        if step not in self._steps:
+    def _validate_secret_and_request(self, step: str, arn: str, metadata: dict[str, Any], request_token: str):
+        """Perform basic checks suggested by AWS of both the request and the secret to ensure validity."""
+        if step not in self.steps:
             raise ClientError(f"Invalid step: {step}")
 
-        if not metadata.get('RotationEnabled'):
+        if not metadata.get("RotationEnabled"):
             raise ValueError("Secret %s is not enabled for rotation" % arn)
 
         versions = metadata["VersionIdsToStages"]
@@ -107,23 +123,31 @@ class SecretsManagerRotation(Base, clearskies.handlers.SchemaHelper):
         if request_token not in versions:
             raise ValueError(f"{prefix} we don't have a stage for rotation")
         if self.current in versions[request_token]:
-            raise ValueError(f"{prefix} it's already the current version, which shouldn't happen.  I'm quitting with prejudice.")
+            raise ValueError(
+                f"{prefix} it's already the current version, which shouldn't happen.  I'm quitting with prejudice."
+            )
         elif self.pending not in versions[request_token]:
             raise ValueError(f"{prefix} it hasn't been set to pending yet, which makes no sense!")
 
     def createSecret(self, **kwargs):
-        new_secret_data = self._di.call_function(self._configuration["createSecret"], **kwargs)
+        new_secret_data = self.di.call_function(self.create_secret, **kwargs)
         if new_secret_data is None:
-            raise ValueError(f"I called the configured createSecret function but it didn't return anything.  It has to return the new secret data.")
+            raise ValueError(
+                f"I called the configured createSecret function but it didn't return anything.  It has to return the new secret data."
+            )
         if not isinstance(new_secret_data, dict):
-            raise ValueError(f"I called the configured createSecret function but it didn't return a dictionary.  The createSecret function must return a dictionary.")
+            raise ValueError(
+                f"I called the configured createSecret function but it didn't return a dictionary.  The createSecret function must return a dictionary."
+            )
 
         secret_errors = {
             **self._extra_column_errors(new_secret_data),
-            **self._find_input_errors(new_secret_data),
+            **self.find_input_errors(new_secret_data),
         }
         if secret_errors:
-            raise ValueError(f"The secret data returned by the call to createSecret did not match the configured schema: {secret_errors}")
+            raise ValueError(
+                f"The secret data returned by the call to createSecret did not match the configured schema: {secret_errors}"
+            )
 
         # if we get this far we can store the new data
         secretsmanager = kwargs["secretsmanager"]
@@ -167,8 +191,5 @@ class SecretsManagerRotation(Base, clearskies.handlers.SchemaHelper):
 
         # finish the rotation by taking the new version and making it current.
         secretsmanager.update_secret_version_stage(
-            SecretId=arn,
-            VersionStage=self.current,
-            MoveToVersionId=request_token,
-            RemoveFromVersionId=current_version
+            SecretId=arn, VersionStage=self.current, MoveToVersionId=request_token, RemoveFromVersionId=current_version
         )

clearskies_aws/endpoints/simple_body_routing.py

@@ -0,0 +1,41 @@
+from __future__ import annotations
+
+import json
+from typing import Any
+
+from clearskies import Endpoint
+from clearskies.configs import AnyDict, String
+from clearskies.di.inject import Di
+from clearskies.input_outputs import InputOutput
+
+
+class SimpleBodyRouting(Endpoint):
+    di = Di()
+
+    route_key = String(default="route")
+    routes = AnyDict(default={})
+
+    def __init__(self, routes: dict[str, Any], route_key: str = "route"):
+        self.routes = routes
+        self.route_key = route_key
+
+    def handle(self, input_output: InputOutput) -> Any:
+        body = json.loads(input_output.get_body()) if input_output.has_body() else {}
+
+        if not body or not body.get(self.route_key):
+            return self.error(input_output, "Not Found", 404)
+
+        route = body[self.route_key]
+        if route not in self.routes:
+            return self.error(input_output, "Not Found", 404)
+        return input_output.respond(
+            self.di.call_function(
+                self.routes[route],
+                request_data=body,
+                **input_output.context_specifics(),
+            ),
+            200,
+        )
+
+    def documentation(self):
+        return []

clearskies_aws/input_outputs/__init__.py

@@ -1,8 +1,21 @@
-from .cli_websocket_mock import CLIWebsocketMock
-from .lambda_api_gateway import LambdaAPIGateway
-from .lambda_api_gateway_web_socket import LambdaAPIGatewayWebSocket
-from .lambda_elb import LambdaELB
-from .lambda_http_gateway import LambdaHTTPGateway
-from .lambda_invocation import LambdaInvocation
-from .lambda_sqs_standard import LambdaSqsStandard
-from .lambda_sns import LambdaSns
+from __future__ import annotations
+
+from clearskies_aws.input_outputs.cli_web_socket_mock import CliWebSocketMock
+from clearskies_aws.input_outputs.lambda_alb import LambdaAlb
+from clearskies_aws.input_outputs.lambda_api_gateway import LambdaApiGateway
+from clearskies_aws.input_outputs.lambda_api_gateway_web_socket import (
+    LambdaApiGatewayWebSocket,
+)
+from clearskies_aws.input_outputs.lambda_invocation import LambdaInvocation
+from clearskies_aws.input_outputs.lambda_sns import LambdaSns
+from clearskies_aws.input_outputs.lambda_sqs_standard import LambdaSqsStandard
+
+__all__ = [
+    "CliWebSocketMock",
+    "LambdaApiGateway",
+    "LambdaApiGatewayWebSocket",
+    "LambdaAlb",
+    "LambdaInvocation",
+    "LambdaSns",
+    "LambdaSqsStandard",
+]

clearskies_aws/input_outputs/{cli_websocket_mock.py → cli_web_socket_mock.py}

@@ -1,9 +1,15 @@
+from __future__ import annotations
+
+import json
+
 import clearskies
-class CLIWebsocketMock(clearskies.input_outputs.CLI):
+
+
+class CliWebSocketMock(clearskies.input_outputs.Cli):
     def context_specifics(self):
-        connection_id = self.json_body().get("connection_id")
+        connection_id = json.loads(self.get_body()).get("connection_id")
         if not connection_id:
-            raise KeyError("When using the CLIWebsocketMock you must provide connection_id in the request body")
+            raise KeyError("When using the CliWebsocketMock you must provide connection_id in the request body")
 
         return {
             "event": {},

clearskies_aws/input_outputs/lambda_alb.py

@@ -0,0 +1,53 @@
+from __future__ import annotations
+
+from typing import Any
+
+from clearskies.configs import String
+from clearskies.input_outputs import Headers
+
+from clearskies_aws.input_outputs import lambda_input_output
+
+
+class LambdaAlb(lambda_input_output.LambdaInputOutput):
+    """Application Load Balancer specific Lambda input/output handler."""
+
+    def __init__(self, event: dict[str, Any], context: dict[str, Any]):
+        # Call parent constructor
+        super().__init__(event, context)
+
+        # ALB specific initialization
+        self.request_method = event.get("httpMethod", "GET").upper()
+        self.path = event.get("path", "/")
+
+        # Extract query parameters (ALB only has single value query parameters)
+        self.query_parameters = event.get("queryStringParameters") or {}
+
+        # Extract headers (ALB only has single value headers)
+        headers_dict = {}
+        for key, value in event.get("headers", {}).items():
+            headers_dict[key.lower()] = str(value)
+
+        self.request_headers = Headers(headers_dict)
+
+    def get_client_ip(self) -> str:
+        """Get the client IP address from ALB headers."""
+        # ALB always provides client IP via X-Forwarded-For header
+        forwarded_for = self.request_headers.get("x-forwarded-for")
+        if not forwarded_for:
+            raise KeyError(
+                "The x-forwarded-for header wasn't present in the request, and it should always exist for anything behind an ALB.  You are probably using the wrong context."
+            )
+
+        # X-Forwarded-For can contain multiple IPs, take the first one
+        return forwarded_for.split(",")[0].strip()
+
+    def context_specifics(self) -> dict[str, Any]:
+        """Provide ALB specific context data."""
+        request_context = self.event.get("requestContext", {})
+        elb = request_context.get("elb", {})
+
+        return {
+            **super().context_specifics(),
+            "path": self.path,
+            "target_group_arn": elb.get("targetGroupArn"),
+        }

clearskies_aws/input_outputs/lambda_api_gateway.py

@@ -1,105 +1,123 @@
-from clearskies.input_outputs.input_output import InputOutput
-import json
-import base64
-import urllib
-class LambdaAPIGateway(InputOutput):
-    _event = None
-    _context = None
-    _request_headers = None
-    _request_method = None
-    _path = None
-    _resource = None
-    _query_parameters = None
-    _path_parameters = None
-    _cached_body = None
-    _body_was_cached = False
-
-    def __init__(self, event, context):
-        self._event = event
-        self._context = context
-        self._request_method = event.get('httpMethod', '').upper()
-        self._path = event.get('path')
-        self._resource = event.get('resource')
-        self._query_parameters = event.get('queryStringParameters', {})
-        self._path_parameters = event.get('pathParameters', {})
-        self._request_headers = {}
-        for (key, value) in event.get('headers', {}).items():
-            self._request_headers[key.lower()] = value
-
-    def respond(self, body, status_code=200):
-        if not self.has_header('content-type'):
-            self.set_header('content-type', 'application/json; charset=UTF-8')
-
-        is_base64 = False
-        if type(body) == bytes:
-            is_base64 = True
-            final_body = base64.encodebytes(body).decode('utf8')
-        elif type(body) == str:
-            final_body = body
-        else:
-            final_body = json.dumps(body)
+from __future__ import annotations
 
-        return {
-            "isBase64Encoded": is_base64,
-            "statusCode": status_code,
-            "headers": self._response_headers,
-            "body": final_body,
+from typing import Any
+
+from clearskies.configs import String
+from clearskies.input_outputs import Headers
+
+from clearskies_aws.input_outputs import lambda_input_output
+
+
+class LambdaApiGateway(lambda_input_output.LambdaInputOutput):
+    """API Gateway v1 and v2 Lambda input/output handler."""
+
+    resource = String(default="")
+
+    def __init__(self, event: dict, context: dict[str, Any]):
+        # Call parent constructor
+        super().__init__(event, context)
+
+        # Determine API Gateway version and parse accordingly
+        version = self._detect_version(event)
+        if version == "1.0":
+            self._parse_event_v1(event)
+        elif version == "2.0":
+            self._parse_event_v2(event)
+        else:
+            raise ValueError(f"Unsupported API Gateway event version: {version}")
+
+    def _detect_version(self, event: dict) -> str:
+        """Detect API Gateway version from event structure."""
+        if "version" in event:
+            return event["version"]
+        elif "httpMethod" in event:
+            return "1.0"  # v1 has httpMethod at root level
+        elif "requestContext" in event and "http" in event["requestContext"]:
+            return "2.0"  # v2 has http in requestContext
+        else:
+            raise ValueError("Unable to determine API Gateway version from event structure")
+
+    def _parse_event_v1(self, event: dict) -> None:
+        """Parse API Gateway v1 event structure."""
+        self.request_method = event.get("httpMethod", "GET").upper()
+        self.path = event.get("path", "/")
+        self.resource = event.get("resource", "")
+
+        # Extract query parameters (v1 has both single and multi-value)
+        self.query_parameters = {
+            **(event.get("queryStringParameters") or {}),
+            **(event.get("multiValueQueryStringParameters") or {}),
         }
 
-    def has_body(self):
-        return bool(self.get_body())
+        # Extract headers (v1 has both single and multi-value)
+        headers_dict = {}
+        for key, value in {
+            **event.get("headers", {}),
+            **event.get("multiValueHeaders", {}),
+        }.items():
+            headers_dict[key.lower()] = str(value)
 
-    def get_body(self):
-        if not self._body_was_cached:
-            self._cached_body = self._event.get('body')
-            if self._cached_body is not None and self._event.get('isBase64Encoded'):
-                self._cached_body = base64.decodebytes(self._cached_body.encode('utf-8')).decode('utf-8')
-        return self._cached_body
+        self.request_headers = Headers(headers_dict)
 
-    def get_request_method(self):
-        return self._request_method
+    def _parse_event_v2(self, event: dict) -> None:
+        """Parse API Gateway v2 event structure."""
+        request_context = event.get("requestContext", {})
+        http_context = request_context.get("http", {})
 
-    def get_script_name(self):
-        return ''
+        self.request_method = http_context.get("method", "GET").upper()
+        self.path = http_context.get("path", "/")
+        # v2 doesn't have resource field
+        self.resource = ""
 
-    def get_path_info(self):
-        return self._path
+        # Extract query parameters (v2 only has single values)
+        self.query_parameters = event.get("queryStringParameters") or {}
 
-    def get_query_string(self):
-        return urllib.parse.urlencode(self._query_parameters)
+        # Extract headers (v2 only has single value headers)
+        headers_dict = {}
+        for key, value in event.get("headers", {}).items():
+            headers_dict[key.lower()] = str(value)
 
-    def get_content_type(self):
-        return self.get_request_header('content-type', True)
+        self.request_headers = Headers(headers_dict)
 
-    def get_protocol(self):
-        return 'https'
+    def get_client_ip(self) -> str:
+        """Get the client IP address from API Gateway event."""
+        request_context = self.event.get("requestContext", {})
 
-    def has_request_header(self, header_name):
-        return header_name.lower() in self._request_headers
+        # Try v1 format first (identity.sourceIp)
+        identity = request_context.get("identity", {})
+        if "sourceIp" in identity:
+            return identity["sourceIp"]
 
-    def get_request_header(self, header_name, silent=False):
-        if not header_name.lower() in self._request_headers:
-            if not silent:
-                raise KeyError(f"HTTP header '{header_name}' was not found in request")
-            return ''
-        return self._request_headers[header_name.lower()]
+        # Try v2 format (http.sourceIp)
+        http_context = request_context.get("http", {})
+        if "sourceIp" in http_context:
+            return http_context["sourceIp"]
 
-    def get_query_parameter(self, key):
-        return self._query_parameters[key] if key in self._query_parameters else []
+        raise ValueError("Unable to find the client ip inside the API Gateway")
 
-    def get_query_parameters(self):
-        return self._query_parameters
+    def get_protocol(self) -> str:
+        """Get the protocol from API Gateway request context."""
+        request_context = self.event.get("requestContext", {})
 
-    def context_specifics(self):
-        return {
-            "event": self._event,
-            "context": self._context,
-        }
+        # Try v2 format first (has explicit protocol)
+        http_context = request_context.get("http", {})
+        if "protocol" in http_context:
+            protocol = http_context["protocol"]
+            return "https" if protocol.upper().startswith("HTTPS") else "http"
+
+        # v1 defaults to HTTPS
+        return "https"
 
-    def get_client_ip(self):
-        # I haven't actually tested with an API gateway yet to figure out which of these works...
-        sourceIp = self._event.get('requestContext', {}).get('identity', {}).get('sourceIp')
-        if sourceIp:
-            return sourceIp
+    def context_specifics(self) -> dict[str, Any]:
+        """Provide API Gateway specific context data."""
+        request_context = self.event.get("requestContext", {})
+        http_context = request_context.get("http", {})
 
-        return self.get_request_header('x-forwarded-for', silent=True)
+        return {
+            **super().context_specifics(),
+            "resource": self.resource,
+            "stage": request_context.get("stage"),
+            "request_id": request_context.get("requestId"),
+            "api_id": request_context.get("apiId"),
+            "api_version": self._detect_version(self.event),
+        }