Middleware return object

[Nils-Mohr-BA]

Hi,
we have started implementing our own middleware, but we are wondering if there is any way to change the object we get back.

At the moment we always get the Response back, but ideally we would like to return our own custom response and we would handle the conversion to the powertools Response in our middleware.

Is there any way to make this work?

Thanks

[leandrodamascena]

Hey! Thanks for raising this question.

I may not have fully understood your question and I'm wondering if you could you share a quick code snippet of what you're trying to achieve?

If you want your handler to return a custom object and convert it to Response in the middleware, that should work today:

from aws_lambda_powertools.event_handler import APIGatewayRestResolver, Response
from dataclasses import dataclass

app = APIGatewayRestResolver()

@dataclass
class MyCustomResponse:
    data: dict
    status: int = 200

def response_converter_middleware(app, next_middleware):
    result = next_middleware(app)
    
    # Already a Response, return as-is
    if isinstance(result, Response):
        return result
    
    # Convert custom response to Powertools Response
    if isinstance(result, MyCustomResponse):
        return Response(
            status_code=result.status,
            content_type="application/json",
            body=result.data,
        )
    
    # Fallback
    return Response(status_code=200, body=result)

app.use([response_converter_middleware])

@app.get("/hello")
def hello():
    # Return your custom object - middleware converts it
    return MyCustomResponse(data={"message": "Hello!"}, status=200)

The middleware wraps next_middleware(app) and transforms the result before returning. The final return must be a Response, but your handlers can return anything as long as your middleware handles the conversion.

[Nils-Mohr-BA]

Hi,

apologies, the code example would have made things easier to understand.

Our example is a little more complicated, but I will try to highlight my question. This may very well be an issue with our setup, cause I am a little confused why the powertools wraps the dataclass in its response object...

Thanks

from dataclasses import dataclass

from aws_lambda_powertools.event_handler import APIGatewayRestResolver, Response
from aws_lambda_powertools.event_handler.middlewares import (
    BaseMiddlewareHandler,
    NextMiddleware,
)

app = APIGatewayRestResolver()


@dataclass
class MyCustomResponse:
    data: dict
    status: int = 200


class ConversionMiddleware(BaseMiddlewareHandler):
    def pre(self):
        # do stuff before request is handled
        pass

    def post(self, response):
        # do stuff after request is handled

        # response here is a Powertools Response object like this:
        # Response(status_code=200, body=MyCustomResponse(...), content_type='application/json')
        # I would like to have just the MyCustomResponse here.

        pass

    def handler(self, app: APIGatewayRestResolver, next_middleware: NextMiddleware) -> Response:
        self.pre()

        # Proceed to the next middleware or handler
        return self.post(next_middleware(app))


@app.get("/hello", middlewares=[ConversionMiddleware])
def hello():
    # Return your custom object - middleware converts it
    return MyCustomResponse(data={"message": "Hello!"}, status=200)

[Nils-Mohr-BA]

Hi, we have found a way to simplify our design and this question is no longer necessary for us.