localstack-core 4.6.1.dev60__py3-none-any.whl → 4.10.1.dev12__py3-none-any.whl

localstack/services/apigateway/next_gen/execute_api/header_utils.py

@@ -1,6 +1,6 @@
 import logging
 from collections import defaultdict
-from typing import Iterable
+from collections.abc import Iterable
 
 from werkzeug.datastructures.headers import Headers
 

localstack/services/apigateway/next_gen/execute_api/helpers.py

@@ -4,7 +4,7 @@ import random
 import re
 import time
 from secrets import token_hex
-from typing import Type, TypedDict
+from typing import TypedDict
 
 from moto.apigateway.models import RestAPI as MotoRestAPI
 
@@ -115,7 +115,7 @@ def get_lambda_function_arn_from_invocation_uri(uri: str) -> str:
     return uri.split("functions/")[1].removesuffix("/invocations")
 
 
-def validate_sub_dict_of_typed_dict(typed_dict: Type[TypedDict], obj: dict) -> bool:
+def validate_sub_dict_of_typed_dict(typed_dict: type[TypedDict], obj: dict) -> bool:
     """
     Validate that the object is a subset off the keys of a given `TypedDict`.
     :param typed_dict: the `TypedDict` blueprint

localstack/services/apigateway/next_gen/execute_api/integrations/aws.py

@@ -3,7 +3,7 @@ import json
 import logging
 from functools import lru_cache
 from http import HTTPMethod
-from typing import Literal, Optional, TypedDict
+from typing import Literal, TypedDict
 from urllib.parse import urlparse
 
 import requests
@@ -51,11 +51,11 @@ NO_BODY_METHODS = {
 
 
 class LambdaProxyResponse(TypedDict, total=False):
-    body: Optional[str]
-    statusCode: Optional[int | str]
-    headers: Optional[dict[str, str]]
-    isBase64Encoded: Optional[bool]
-    multiValueHeaders: Optional[dict[str, list[str]]]
+    body: str | None
+    statusCode: int | str | None
+    headers: dict[str, str] | None
+    isBase64Encoded: bool | None
+    multiValueHeaders: dict[str, list[str]] | None
 
 
 class LambdaInputEvent(TypedDict, total=False):
@@ -211,6 +211,9 @@ class RestApiAwsIntegration(RestApiIntegration):
             action = parsed_uri["path"]
 
             if target := self.get_action_service_target(service_name, action):
+                # TODO: properly implement the auto-`Content-Type` headers depending on the service protocol
+                #  e.g. `x-amz-json-1.0` for DynamoDB
+                #  this is needed to properly support multi-protocol
                 headers["X-Amz-Target"] = target
 
             query_params["Action"] = action

localstack/services/apigateway/next_gen/execute_api/integrations/http.py

@@ -1,6 +1,6 @@
 import logging
 from http import HTTPMethod
-from typing import Optional, TypedDict
+from typing import TypedDict
 
 import requests
 from werkzeug.datastructures import Headers
@@ -8,7 +8,7 @@ from werkzeug.datastructures import Headers
 from localstack.aws.api.apigateway import Integration
 
 from ..context import EndpointResponse, IntegrationRequest, RestApiInvocationContext
-from ..gateway_response import ApiConfigurationError, IntegrationFailureError
+from ..gateway_response import ApiConfigurationError, IntegrationFailureError, InternalServerError
 from ..header_utils import build_multi_value_headers
 from .core import RestApiIntegration
 
@@ -20,16 +20,16 @@ NO_BODY_METHODS = {HTTPMethod.OPTIONS, HTTPMethod.GET, HTTPMethod.HEAD}
 class SimpleHttpRequest(TypedDict, total=False):
     method: HTTPMethod | str
     url: str
-    params: Optional[dict[str, str | list[str]]]
+    params: dict[str, str | list[str]] | None
     data: bytes
-    headers: Optional[dict[str, str]]
-    cookies: Optional[dict[str, str]]
-    timeout: Optional[int]
-    allow_redirects: Optional[bool]
-    stream: Optional[bool]
-    verify: Optional[bool]
+    headers: dict[str, str] | None
+    cookies: dict[str, str] | None
+    timeout: int | None
+    allow_redirects: bool | None
+    stream: bool | None
+    verify: bool | None
     # TODO: check if there was a situation where we'd pass certs?
-    cert: Optional[str | tuple[str, str]]
+    cert: str | tuple[str, str] | None
 
 
 class BaseRestApiHttpIntegration(RestApiIntegration):
@@ -72,7 +72,7 @@ class RestApiHttpIntegration(BaseRestApiHttpIntegration):
         except (requests.exceptions.InvalidURL, requests.exceptions.InvalidSchema) as e:
             LOG.warning("Execution failed due to configuration error: Invalid endpoint address")
             LOG.debug("The URI specified for the HTTP/HTTP_PROXY integration is invalid: %s", uri)
-            raise ApiConfigurationError("Internal server error") from e
+            raise InternalServerError("Internal server error") from e
 
         except (requests.exceptions.Timeout, requests.exceptions.SSLError) as e:
             # TODO make the exception catching more fine grained
@@ -127,7 +127,7 @@ class RestApiHttpProxyIntegration(BaseRestApiHttpIntegration):
         except (requests.exceptions.InvalidURL, requests.exceptions.InvalidSchema) as e:
             LOG.warning("Execution failed due to configuration error: Invalid endpoint address")
             LOG.debug("The URI specified for the HTTP/HTTP_PROXY integration is invalid: %s", uri)
-            raise ApiConfigurationError("Internal server error") from e
+            raise InternalServerError("Internal server error") from e
 
         except (requests.exceptions.Timeout, requests.exceptions.SSLError):
             # TODO make the exception catching more fine grained

localstack/services/apigateway/next_gen/execute_api/router.py

@@ -33,6 +33,7 @@ class RouteHostPathParameters(TypedDict, total=False):
     server: str | None
     stage: str | None
     vpce_suffix: str | None
+    vpce_dns: str | None
 
 
 class ApiGatewayEndpoint:
@@ -144,6 +145,13 @@ class ApiGatewayEndpoint:
         )
         return not_found
 
+    def vpc_endpoint_handler(
+        self, request: Request, **kwargs: Unpack[RouteHostPathParameters]
+    ) -> Response:
+        # TODO validate the vpc endpoint exists in the account/region before routing
+        kwargs["api_id"] = request.headers.get("x-apigw-api-id")
+        return self.__call__(request, **kwargs)
+
 
 class ApiGatewayRouter:
     router: Router[Handler]
@@ -158,6 +166,9 @@ class ApiGatewayRouter:
     def register_routes(self) -> None:
         LOG.debug("Registering API Gateway routes.")
         host_pattern = "<regex('.+?'):api_id><regex('(-vpce-[^.]+)?'):vpce_suffix>.execute-api.<regex('.*'):server>"
+        vpce_host_pattern = (
+            "<regex('vpce-.+'):vpce_dns>.execute-api.<regex('.*'):region>vpce.<regex('.*'):server>"
+        )
         deprecated_route_endpoint = deprecated_endpoint(
             endpoint=self.handler,
             previous_path="/restapis/<api_id>/<stage>/_user_request_",
@@ -214,6 +225,26 @@ class ApiGatewayRouter:
                 endpoint=self.handler,
                 strict_slashes=True,
             ),
+            self.router.add(
+                path="/",
+                host=vpce_host_pattern,
+                endpoint=self.handler.vpc_endpoint_handler,
+                defaults={"path": "", "stage": None},
+                strict_slashes=True,
+            ),
+            self.router.add(
+                path="/<stage>/",
+                host=vpce_host_pattern,
+                endpoint=self.handler.vpc_endpoint_handler,
+                defaults={"path": ""},
+                strict_slashes=False,
+            ),
+            self.router.add(
+                path="/<stage>/<greedy_path:path>",
+                host=vpce_host_pattern,
+                endpoint=self.handler.vpc_endpoint_handler,
+                strict_slashes=True,
+            ),
         ]
         for rule in rules:
             self.registered_rules.append(rule)

localstack/services/apigateway/next_gen/execute_api/template_mapping.py

@@ -109,7 +109,7 @@ class VTLJsonList(list):
     """
 
     def __init__(self, *args):
-        super(VTLJsonList, self).__init__(*args)
+        super().__init__(*args)
         for idx, item in enumerate(self):
             self[idx] = cast_to_vtl_json_object(item)
 
@@ -138,7 +138,7 @@ class AttributeDict(dict):
     """
 
     def __init__(self, *args, **kwargs):
-        super(AttributeDict, self).__init__(*args, **kwargs)
+        super().__init__(*args, **kwargs)
         for key, value in self.items():
             if isinstance(value, dict):
                 self[key] = AttributeDict(value)

localstack/services/apigateway/next_gen/execute_api/test_invoke.py

@@ -1,4 +1,5 @@
 import datetime
+import logging
 from urllib.parse import parse_qs
 
 from rolo import Request
@@ -22,6 +23,9 @@ from .variables import (
     ContextVarsResponseOverride,
 )
 
+LOG = logging.getLogger(__name__)
+
+
 # TODO: we probably need to write and populate those logs as part of the handler chain itself
 #  and store it in the InvocationContext. That way, we could also retrieve in when calling TestInvoke
 
@@ -45,6 +49,30 @@ TEST_INVOKE_TEMPLATE = """Execution log for request {request_id}
 {formatted_date} : Method completed with status: {method_response_status}
 """
 
+TEST_INVOKE_TEMPLATE_MOCK = """Execution log for request {request_id}
+{formatted_date} : Starting execution for request: {request_id}
+{formatted_date} : HTTP Method: {request_method}, Resource Path: {resource_path}
+{formatted_date} : Method request path: {method_request_path_parameters}
+{formatted_date} : Method request query string: {method_request_query_string}
+{formatted_date} : Method request headers: {method_request_headers}
+{formatted_date} : Method request body before transformations: {method_request_body}
+{formatted_date} : Method response body after transformations: {method_response_body}
+{formatted_date} : Method response headers: {method_response_headers}
+{formatted_date} : Successfully completed execution
+{formatted_date} : Method completed with status: {method_response_status}
+"""
+
+TEST_INVOKE_TEMPLATE_FAILED = """Execution log for request {request_id}
+{formatted_date} : Starting execution for request: {request_id}
+{formatted_date} : HTTP Method: {request_method}, Resource Path: {resource_path}
+{formatted_date} : Method request path: {method_request_path_parameters}
+{formatted_date} : Method request query string: {method_request_query_string}
+{formatted_date} : Method request headers: {method_request_headers}
+{formatted_date} : Method request body before transformations: {method_request_body}
+{formatted_date} : Execution failed due to {error_type}: {error_message}
+{formatted_date} : Method completed with status: {method_response_status}
+"""
+
 
 def _dump_headers(headers: Headers) -> str:
     if not headers:
@@ -63,9 +91,9 @@ def log_template(invocation_context: RestApiInvocationContext, response_headers:
     formatted_date = datetime.datetime.now(tz=datetime.UTC).strftime("%a %b %d %H:%M:%S %Z %Y")
     request = invocation_context.invocation_request
     context_var = invocation_context.context_variables
-    integration_req = invocation_context.integration_request
-    endpoint_resp = invocation_context.endpoint_response
-    method_resp = invocation_context.invocation_response
+    integration_req = invocation_context.integration_request or {}
+    endpoint_resp = invocation_context.endpoint_response or {}
+    method_resp = invocation_context.invocation_response or {}
     # TODO: if endpoint_uri is an ARN, it means it's an AWS_PROXY integration
     #  this should be transformed to the true URL of a lambda invoke call
     endpoint_uri = integration_req.get("uri", "")
@@ -93,6 +121,52 @@ def log_template(invocation_context: RestApiInvocationContext, response_headers:
     )
 
 
+def log_mock_template(
+    invocation_context: RestApiInvocationContext, response_headers: Headers
+) -> str:
+    formatted_date = datetime.datetime.now(tz=datetime.UTC).strftime("%a %b %d %H:%M:%S %Z %Y")
+    request = invocation_context.invocation_request
+    context_var = invocation_context.context_variables
+    method_resp = invocation_context.invocation_response or {}
+
+    return TEST_INVOKE_TEMPLATE_MOCK.format(
+        formatted_date=formatted_date,
+        request_id=context_var["requestId"],
+        resource_path=request["path"],
+        request_method=request["http_method"],
+        method_request_path_parameters=dict_to_string(request["path_parameters"]),
+        method_request_query_string=dict_to_string(request["query_string_parameters"]),
+        method_request_headers=_dump_headers(request.get("headers")),
+        method_request_body=to_str(request.get("body", "")),
+        method_response_status=method_resp.get("status_code"),
+        method_response_body=to_str(method_resp.get("body", "")),
+        method_response_headers=_dump_headers(response_headers),
+    )
+
+
+def log_failed_template(
+    invocation_context: RestApiInvocationContext, response_status_code: int
+) -> str:
+    formatted_date = datetime.datetime.now(tz=datetime.UTC).strftime("%a %b %d %H:%M:%S %Z %Y")
+    request = invocation_context.invocation_request
+    context_var = invocation_context.context_variables
+
+    return TEST_INVOKE_TEMPLATE_FAILED.format(
+        formatted_date=formatted_date,
+        request_id=context_var["requestId"],
+        resource_path=request["path"],
+        request_method=request["http_method"],
+        method_request_path_parameters=dict_to_string(request["path_parameters"]),
+        method_request_query_string=dict_to_string(request["query_string_parameters"]),
+        method_request_headers=_dump_headers(request.get("headers")),
+        method_request_body=to_str(request.get("body", "")),
+        method_response_status=response_status_code,
+        # TODO: fix the error message
+        error_type="",
+        error_message="",
+    )
+
+
 def create_test_chain() -> HandlerChain[RestApiInvocationContext]:
     return HandlerChain(
         request_handlers=[
@@ -114,13 +188,16 @@ def create_test_invocation_context(
 ) -> RestApiInvocationContext:
     parse_handler = handlers.parse_request
     http_method = test_request["httpMethod"]
+    resource = deployment.rest_api.resources[test_request["resourceId"]]
+    resource_path = resource["path"]
 
     # we do not need a true HTTP request for the context, as we are skipping all the parsing steps and using the
     # provider data
     invocation_context = RestApiInvocationContext(
         request=Request(method=http_method),
     )
-    path_query = test_request.get("pathWithQueryString", "/").split("?")
+    test_request_path = test_request.get("pathWithQueryString") or resource_path
+    path_query = test_request_path.split("?")
     path = path_query[0]
     multi_query_args: dict[str, list[str]] = {}
 
@@ -140,9 +217,22 @@ def create_test_invocation_context(
         # TODO: handle multiValueHeaders
         body=to_bytes(test_request.get("body") or ""),
     )
+
     invocation_context.invocation_request = invocation_request
+    try:
+        # this is AWS behavior, it will accept any value for the `pathWithQueryString`, even if it doesn't match
+        # the expected format. It will just fall back to no value if it cannot parse the path parameters out of it
+        _, path_parameters = RestAPIResourceRouter(deployment).match(invocation_context)
+    except Exception as e:
+        LOG.warning(
+            "Error while trying to extract path parameters from user-provided 'pathWithQueryString=%s' "
+            "for the following resource path: '%s'. Error: '%s'",
+            path,
+            resource_path,
+            e,
+        )
+        path_parameters = {}
 
-    _, path_parameters = RestAPIResourceRouter(deployment).match(invocation_context)
     invocation_request["path_parameters"] = path_parameters
 
     invocation_context.deployment = deployment
@@ -160,8 +250,9 @@ def create_test_invocation_context(
         responseOverride=ContextVarsResponseOverride(header={}, status=0),
     )
     invocation_context.trace_id = parse_handler.populate_trace_id({})
-    resource = deployment.rest_api.resources[test_request["resourceId"]]
-    resource_method = resource["resourceMethods"][http_method]
+    resource_method = (
+        resource["resourceMethods"].get(http_method) or resource["resourceMethods"]["ANY"]
+    )
     invocation_context.resource = resource
     invocation_context.resource_method = resource_method
     invocation_context.integration = resource_method["methodIntegration"]
@@ -179,8 +270,10 @@ def run_test_invocation(
     invocation_context = create_test_invocation_context(test_request, deployment)
 
     test_chain = create_test_chain()
+    is_mock_integration = invocation_context.integration["type"] == "MOCK"
+
     # header order is important
-    if invocation_context.integration["type"] == "MOCK":
+    if is_mock_integration:
         base_headers = {"Content-Type": APPLICATION_JSON}
     else:
         # we manually add the trace-id, as it is normally added by handlers.response_enricher which adds to much data
@@ -199,7 +292,19 @@ def run_test_invocation(
     # AWS does not return the Content-Length for TestInvokeMethod
     response_headers.remove("Content-Length")
 
-    log = log_template(invocation_context, response_headers)
+    if not invocation_context.invocation_response:
+        # TODO: this is an heuristic to guess if we encounter an exception in the call
+        #  in the future, we should attach the exception to the context so we could act on it and properly
+        #  log as we go through the invocation, so that if we have an error we stop logging at the right moment
+        for header in ("Content-Type", "X-Amzn-Trace-Id"):
+            response_headers.remove(header)
+        log = log_failed_template(invocation_context, test_response.status_code)
+
+    elif is_mock_integration:
+        # TODO: revisit how we're building the logs
+        log = log_mock_template(invocation_context, response_headers)
+    else:
+        log = log_template(invocation_context, response_headers)
 
     headers = dict(response_headers)
     multi_value_headers = build_multi_value_headers(response_headers)

localstack/services/apigateway/next_gen/execute_api/variables.py

@@ -1,4 +1,4 @@
-from typing import Optional, TypedDict
+from typing import TypedDict
 
 
 class ContextVarsAuthorizer(TypedDict, total=False):
@@ -6,9 +6,9 @@ class ContextVarsAuthorizer(TypedDict, total=False):
     # format
 
     # https://docs.aws.amazon.com/apigateway/latest/developerguide/api-gateway-mapping-template-reference.html
-    claims: Optional[dict[str, str]]
+    claims: dict[str, str] | None
     """Claims returned from the Amazon Cognito user pool after the method caller is successfully authenticated"""
-    principalId: Optional[str]
+    principalId: str | None
     """The principal user identification associated with the token sent by the client and returned from an API Gateway Lambda authorizer"""
 
 
@@ -29,38 +29,38 @@ class ContextVarsIdentityClientCert(TypedDict, total=False):
 
 class ContextVarsIdentity(TypedDict, total=False):
     # https://docs.aws.amazon.com/apigateway/latest/developerguide/api-gateway-mapping-template-reference.html
-    accountId: Optional[str]
+    accountId: str | None
     """The AWS account ID associated with the request."""
-    accessKey: Optional[str]
+    accessKey: str | None
     """The AWS access key associated with the request."""
-    apiKey: Optional[str]
+    apiKey: str | None
     """For API methods that require an API key, this variable is the API key associated with the method request."""
-    apiKeyId: Optional[str]
+    apiKeyId: str | None
     """The API key ID associated with an API request that requires an API key."""
-    caller: Optional[str]
+    caller: str | None
     """The principal identifier of the caller that signed the request. Supported for resources that use IAM authorization."""
-    cognitoAuthenticationProvider: Optional[str]
+    cognitoAuthenticationProvider: str | None
     """A comma-separated list of the Amazon Cognito authentication providers used by the caller making the request"""
-    cognitoAuthenticationType: Optional[str]
+    cognitoAuthenticationType: str | None
     """The Amazon Cognito authentication type of the caller making the request"""
-    cognitoIdentityId: Optional[str]
+    cognitoIdentityId: str | None
     """The Amazon Cognito identity ID of the caller making the request"""
-    cognitoIdentityPoolId: Optional[str]
+    cognitoIdentityPoolId: str | None
     """The Amazon Cognito identity pool ID of the caller making the request"""
-    principalOrgId: Optional[str]
+    principalOrgId: str | None
     """The AWS organization ID."""
-    sourceIp: Optional[str]
+    sourceIp: str | None
     """The source IP address of the immediate TCP connection making the request to the API Gateway endpoint"""
     clientCert: ContextVarsIdentityClientCert
-    vpcId: Optional[str]
+    vpcId: str | None
     """The VPC ID of the VPC making the request to the API Gateway endpoint."""
-    vpceId: Optional[str]
+    vpceId: str | None
     """The VPC endpoint ID of the VPC endpoint making the request to the API Gateway endpoint."""
-    user: Optional[str]
+    user: str | None
     """The principal identifier of the user that will be authorized against resource access for resources that use IAM authorization."""
-    userAgent: Optional[str]
+    userAgent: str | None
     """The User-Agent header of the API caller."""
-    userArn: Optional[str]
+    userArn: str | None
     """The Amazon Resource Name (ARN) of the effective user identified after authentication."""
 
 
@@ -95,9 +95,9 @@ class ContextVariables(TypedDict, total=False):
     """The API owner's AWS account ID."""
     apiId: str
     """The identifier API Gateway assigns to your API."""
-    authorizer: Optional[ContextVarsAuthorizer]
+    authorizer: ContextVarsAuthorizer | None
     """The principal user identification associated with the token."""
-    awsEndpointRequestId: Optional[str]
+    awsEndpointRequestId: str | None
     """The AWS endpoint's request ID."""
     deploymentId: str
     """The ID of the API deployment."""
@@ -111,8 +111,8 @@ class ContextVariables(TypedDict, total=False):
     """The extended ID that API Gateway generates and assigns to the API request. """
     httpMethod: str
     """The HTTP method used"""
-    identity: Optional[ContextVarsIdentity]
-    isCanaryRequest: Optional[bool]
+    identity: ContextVarsIdentity | None
+    isCanaryRequest: bool | None
     """Indicates if the request was directed to the canary"""
     path: str
     """The request path."""
@@ -120,76 +120,76 @@ class ContextVariables(TypedDict, total=False):
     """The request protocol"""
     requestId: str
     """An ID for the request. Clients can override this request ID. """
-    requestOverride: Optional[ContextVarsRequestOverride]
+    requestOverride: ContextVarsRequestOverride | None
     """Request override. Only exists for request mapping template"""
     requestTime: str
     """The CLF-formatted request time (dd/MMM/yyyy:HH:mm:ss +-hhmm)."""
     requestTimeEpoch: int
     """The Epoch-formatted request time, in milliseconds."""
-    resourceId: Optional[str]
+    resourceId: str | None
     """The identifier that API Gateway assigns to your resource."""
-    resourcePath: Optional[str]
+    resourcePath: str | None
     """The path to your resource"""
-    responseOverride: Optional[ContextVarsResponseOverride]
+    responseOverride: ContextVarsResponseOverride | None
     """Response override. Only exists for response mapping template"""
     stage: str
     """The deployment stage of the API request """
-    wafResponseCode: Optional[str]
+    wafResponseCode: str | None
     """The response received from AWS WAF: WAF_ALLOW or WAF_BLOCK. Will not be set if the stage is not associated with a web ACL"""
-    webaclArn: Optional[str]
+    webaclArn: str | None
     """The complete ARN of the web ACL that is used to decide whether to allow or block the request. Will not be set if the stage is not associated with a web ACL."""
 
 
 class LoggingContextVarsAuthorize(TypedDict, total=False):
-    error: Optional[str]
-    latency: Optional[str]
-    status: Optional[str]
+    error: str | None
+    latency: str | None
+    status: str | None
 
 
 class LoggingContextVarsAuthorizer(TypedDict, total=False):
-    error: Optional[str]
-    integrationLatency: Optional[str]
-    integrationStatus: Optional[str]
-    latency: Optional[str]
-    requestId: Optional[str]
-    status: Optional[str]
+    error: str | None
+    integrationLatency: str | None
+    integrationStatus: str | None
+    latency: str | None
+    requestId: str | None
+    status: str | None
 
 
 class LoggingContextVarsAuthenticate(TypedDict, total=False):
-    error: Optional[str]
-    latency: Optional[str]
-    status: Optional[str]
+    error: str | None
+    latency: str | None
+    status: str | None
 
 
 class LoggingContextVarsCustomDomain(TypedDict, total=False):
-    basePathMatched: Optional[str]
+    basePathMatched: str | None
 
 
 class LoggingContextVarsIntegration(TypedDict, total=False):
-    error: Optional[str]
-    integrationStatus: Optional[str]
-    latency: Optional[str]
-    requestId: Optional[str]
-    status: Optional[str]
+    error: str | None
+    integrationStatus: str | None
+    latency: str | None
+    requestId: str | None
+    status: str | None
 
 
 class LoggingContextVarsWaf(TypedDict, total=False):
-    error: Optional[str]
-    latency: Optional[str]
-    status: Optional[str]
+    error: str | None
+    latency: str | None
+    status: str | None
 
 
 class LoggingContextVariables(TypedDict, total=False):
-    authorize: Optional[LoggingContextVarsAuthorize]
-    authorizer: Optional[LoggingContextVarsAuthorizer]
-    authenticate: Optional[LoggingContextVarsAuthenticate]
-    customDomain: Optional[LoggingContextVarsCustomDomain]
-    endpointType: Optional[str]
-    integration: Optional[LoggingContextVarsIntegration]
-    integrationLatency: Optional[str]
-    integrationStatus: Optional[str]
-    responseLatency: Optional[str]
-    responseLength: Optional[str]
-    status: Optional[str]
-    waf: Optional[LoggingContextVarsWaf]
-    xrayTraceId: Optional[str]
+    authorize: LoggingContextVarsAuthorize | None
+    authorizer: LoggingContextVarsAuthorizer | None
+    authenticate: LoggingContextVarsAuthenticate | None
+    customDomain: LoggingContextVarsCustomDomain | None
+    endpointType: str | None
+    integration: LoggingContextVarsIntegration | None
+    integrationLatency: str | None
+    integrationStatus: str | None
+    responseLatency: str | None
+    responseLength: str | None
+    status: str | None
+    waf: LoggingContextVarsWaf | None
+    xrayTraceId: str | None

localstack/services/apigateway/next_gen/provider.py

@@ -429,6 +429,11 @@ class ApigatewayNextGenProvider(ApigatewayProvider):
         if not resource:
             raise NotFoundException("Invalid Resource identifier specified")
 
+        resource_methods = resource.resource_methods
+
+        if request["httpMethod"] not in resource_methods and "ANY" not in resource_methods:
+            raise NotFoundException("Invalid Method identifier specified")
+
         # test httpMethod
 
         rest_api_container = get_rest_api_container(context, rest_api_id=rest_api_id)

localstack/services/apigateway/resource_providers/aws_apigateway_account.py

@@ -2,7 +2,7 @@
 from __future__ import annotations
 
 from pathlib import Path
-from typing import Optional, TypedDict
+from typing import TypedDict
 
 import localstack.services.cloudformation.provider_utils as util
 from localstack.services.cloudformation.resource_provider import (
@@ -14,8 +14,8 @@ from localstack.services.cloudformation.resource_provider import (
 
 
 class ApiGatewayAccountProperties(TypedDict):
-    CloudWatchRoleArn: Optional[str]
-    Id: Optional[str]
+    CloudWatchRoleArn: str | None
+    Id: str | None
 
 
 REPEATED_INVOCATION = "repeated_invocation"

localstack/services/apigateway/resource_providers/aws_apigateway_account_plugin.py

@@ -1,5 +1,3 @@
-from typing import Optional, Type
-
 from localstack.services.cloudformation.resource_provider import (
     CloudFormationResourceProviderPlugin,
     ResourceProvider,
@@ -10,7 +8,7 @@ class ApiGatewayAccountProviderPlugin(CloudFormationResourceProviderPlugin):
     name = "AWS::ApiGateway::Account"
 
     def __init__(self):
-        self.factory: Optional[Type[ResourceProvider]] = None
+        self.factory: type[ResourceProvider] | None = None
 
     def load(self):
         from localstack.services.apigateway.resource_providers.aws_apigateway_account import (