Feature request: Expose Starlette API app so it can be mounted onto an existing FastAPI/ASGI app

[jklaise]

I'd like to be able to mount the API app on my existing FastAPI app to access the dashboard. This would simplify deployment - one less service and no need for a reverse proxy. Though I'm not sure if it would play well with the plugin architecture in general.

[jklaise]

I had a go at this - it's straightforward to factor out getting the Startlette app from the Api class, but I think it's not possible to mount it on anywhere other than the root path due to the SPA setup.

For reference on the Python side:

class MountableApi(Api):
    """Api subclass that exposes the Starlette app for mounting"""

    def create_app(self, chancy: Chancy, worker: Worker) -> Starlette:
        # Extract app creation logic from run() method
        for plug in chancy.plugins.values():
            api_plugin = plug.api_plugin()
            if api_plugin is None:
                continue

            api_plugin = import_string(api_plugin)
            if not issubclass(api_plugin, ApiPlugin):
                continue

            self.plugins.add(api_plugin)

        def _r(f):
            return partial(f, chancy=chancy, worker=worker)

        app = Starlette(
            debug=self.debug,
            middleware=[
                Middleware(
                    CORSMiddleware,
                    allow_origins=self.allow_origins,
                ),
                Middleware(SessionMiddleware, secret_key=self.secret_key),
                Middleware(
                    AuthenticationMiddleware,
                    backend=self.authentication_backend,
                ),
            ],
        )

        web_plugins = []
        # Look through all the enabled plugins for any that implement the
        # ApiPlugin interface. If they do, we merge them into our Starlette
        # app.
        for api_plugin in self.plugins:
            wp = api_plugin(self)
            web_plugins.append(wp)
            chancy.log.info(f"Loading API sub-plugin {wp.name()}")

            for route in wp.routes():
                if route.get("is_websocket"):
                    app.add_websocket_route(
                        route["path"],
                        _r(route["endpoint"]),
                        name=route["name"],
                    )
                else:
                    app.add_route(
                        route["path"],
                        _r(route["endpoint"]),
                        methods=route["methods"],
                        name=route["name"],
                    )

        # Add the wildcard route to the end of the list so that it doesn't
        # override any other routes and serves anything that should be handled
        # by the UI SPA.
        app.mount(
            "/",
            _SPAStaticFiles(
                packages=[("chancy.plugins.api", "dist")],
                html=True,
            ),
            name="ui",
        )

        return app

    async def run(self, worker: Worker, chancy: Chancy):
        # should be no-op if mounted?
        app = self.create_app(worker, chancy)

        server = uvicorn.Server(
            config=uvicorn.Config(
                app=app,
                host=self.host,
                port=self.port,
                log_level="error",
            )
        )

        chancy.log.info(f"Dashboard running at http://{self.host}:{self.port}")
        
        await server.serve()

Then in main:

api = MountableApi(authentication_backend=authentication_backend, secret_key=secret_key)
chancy = Chancy(URI, plugins=[api])

# mount on existing FastAPI app
app.mount("/", api.create_app(chancy, Worker(chancy)))

[TkTech]

We could definitely support a prefix= setting to adjust where it mounts, we'll just need to ensure it's passed through to the frontend for creating paths.

[TkTech]

Will be incorporated in #58