Connexion 3.0.0 is out now! 🎉

[RobbeSneyders]

Connexion 3.0: API-first for all

We are excited to announce the release of Connexion 3.0! 🎉

Connexion 3 fundamentally changes how Connexion is designed and implemented, and how it
fits into the wider Python API ecosystem. We adopted the ASGI interface, which makes Connexion both
modular and well-integrated with most modern Python API tooling.

It brings some major changes compared to 2.X:

• The improved App and new AsyncApp allow you to use Connexion as a stand-alone framework
  • The App interface was extended so you no longer have to care about the framework used
    underneath
• Connexion can now be used as middleware to supercharge any ASGI or WSGI-compatible framework
  with its spec-based functionality
• Connexion is now pluggable in many dimensions:
  • All Connexion functionality is pluggable by adding or removing middleware from its stack
  • Validation is now pluggable by content type, solving longstanding issues regarding endpoints
    with multiple content types and making it easy to add validation for additional content types
  • Authentication is now pluggable by security scheme, making it easy to customize the behavior or
    add support for additional security schemes.
• Aiohttp support has been dropped due to lack of ASGI support
• We spent a lot of effort on extending and improving our documentation_

For further details, check:

• Our Connexion 3 documentation page for a high level overview of the changes
• Our in-depth blog post on the redesign for technical details
• The release for a detailed overview of all changes

[SpudInNZ]

Congrats!
We've been running the alpha in production (!) for a while now. Maybe that will give other people confidence to make the move if they are considering it.

[RobbeSneyders]

Thanks for the vote of confidence!

[AlonMorgen]

Is there some simplified guide (steps) to do to migrate from 2.x to 3?
It can be very helpful for more projects to be able to migrate fluently to 3.0.0

[RobbeSneyders]

This page lists the changes and highlights the main ones. We'll be updating it based on incoming feedback, so let us know if something is unclear.

[lucas03]

Hey,
firstly thank you for taking over connexion and leaving it there to rot. Kudos!

I am looking into migrating our old connexion app (flask, no async) to connexion 3.

we start add middleware to app like this:

application = create_connexion_app("backoff")
apply_middleware(application, DEFAULT_MIDDLEWARE)

where apply middleware is just this:

def apply_middleware(application: FlaskApp, middleware: list):
    """Apply the provided WSGI middleware to the provided FlaskApp."""
    for wrapper in reversed(middleware):
        # adding middleware directly to the wrapped WSGI application,
        # so that the reference to app object is not lost:
        # http://flask.pocoo.org/docs/1.0/api/#flask.Flask.wsgi_app
        application.app.wsgi_app = wrapper(application.app.wsgi_app)

and connexion app is created like this:

def create_connexion_app(name: str) -> FlaskApp:
    """Return a new instance of connexion.FlaskApp with the provided name.

    Use OpenAPI v3 specification from the package's "schema" directory.
    Also set the openapi_schema attribute on the returned object,
    so that it can be accessed later.
    """
    package_name = f"kw.{name}"
    package = import_module(package_name)
    package_path = path.dirname(path.realpath(package.__file__))
    connexion_app = FlaskApp(package_name)

    connexion_app.app.before_request(inject_route)
    connexion_app.app.before_request(bind_booking_id_to_logger)
    connexion_app.app.before_request(bind_shopping_basket_id_to_logger)
    connexion_app.openapi_schemas = {}

    for specification_path in Path(package_path).rglob("openapi.yaml"):
        root_specification_filepath = path.join(specification_path)
        parser = ResolvingParser(root_specification_filepath, backend="openapi-spec-validator")
        base_path = parser.specification.get("servers", [{"url": "/"}])[0]["url"]
        connexion_app.openapi_schemas[base_path] = parser.specification

        connexion_app.add_api(
            parser.specification,
            validate_responses=True,
            strict_validation=True,
            resolver=RestyResolver(f"{package_name}.handlers"),
            validator_map=validator_map,
        )

        log.info("connexion_app.api_added", specification_path=str(specification_path))

    connexion_app.app.json_encoder = CustomJSONEncoder

    # Distributed tracing is enabled by default:
    # http://pypi.datadoghq.com/trace/docs/web_integrations.html#configuration
    ddtrace_patch(flask=True)
    Pin.override(connexion_app.app, service=name)

    connexion_app.add_error_handler(CustomJSONError, translate_json_error)
    connexion_app.add_error_handler(APIError, lambda error: connexion_app.common_error_handler(map_api_error(error)))
    connexion_app.add_error_handler(Exception, log_and_reraise_error)

    return connexion_app

From docs, I understood it should be either rewritten ASGI classes, or use add_wsgi_middleware. Could you give an example, how middleware like this should be rewritten to be compatible with connexion 3 please?

@wsgify.middleware
def validator(req: webob.Request, app: wsgify) -> webob.Response:
    """Validate request params and body."""
    try:
        # accessing get params checks if we can decode it
        req.params  # noqa: B018
        return req.get_response(app)
    except UnicodeDecodeError as e:
        log.exception("openapi.validator")
        raise HTTPBadRequest("invalid request data") from e

[chase-peach]

Congrats 🥳!

Is there any timeline for the deprecation of 2.x?