apppy-app 0.1.0__tar.gz

apppy_app-0.1.0/.gitignore

@@ -0,0 +1,28 @@
+__generated__/
+dist/
+*.egg-info
+.env
+.env.*
+*.env
+!.env.ci
+.file_store/
+*.pid
+.python-version
+*.secrets
+.secrets
+*.tar.gz
+*.test_output/
+.test_output/
+uv.lock
+*.whl
+
+# System files
+__pycache__
+.DS_Store
+
+# Editor files
+*.sublime-project
+*.sublime-workspace
+.vscode/*
+!.vscode/settings.json
+

apppy_app-0.1.0/PKG-INFO

@@ -0,0 +1,21 @@
+Metadata-Version: 2.4
+Name: apppy-app
+Version: 0.1.0
+Summary: Application definitions and infrastructure for server development
+Project-URL: Homepage, https://github.com/spals/apppy
+Author: Tim Kral
+License: MIT
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.11
+Requires-Dist: apppy-auth>=0.1.0
+Requires-Dist: apppy-db>=0.1.0
+Requires-Dist: apppy-env>=0.1.0
+Requires-Dist: apppy-fastql>=0.1.0
+Requires-Dist: apppy-logger>=0.1.0
+Requires-Dist: click==8.2.1
+Requires-Dist: dependency-injector==4.48.1
+Requires-Dist: fastapi-lifespan-manager==0.1.4
+Requires-Dist: fastapi==0.115.14
+Requires-Dist: strawberry-graphql[fastapi]==0.275.5
+Requires-Dist: uvicorn==0.35.0

apppy_app-0.1.0/app.mk

@@ -0,0 +1,23 @@
+ifndef APPPY_APP_MK_INCLUDED
+APPPY_APP_MK_INCLUDED := 1
+APP_PKG_DIR := $(dir $(abspath $(lastword $(MAKEFILE_LIST))))
+
+.PHONY: app app-dev app/build app/clean app/install app/install-dev
+
+app: app/clean app/install
+
+app-dev: app/clean app/install-dev
+
+app/build:
+	cd $(APP_PKG_DIR) && uvx --from build pyproject-build
+
+app/clean:
+	cd $(APP_PKG_DIR) && rm -rf dist/ *.egg-info .venv
+
+app/install: app/build
+	cd $(APP_PKG_DIR) && uv pip install dist/*.whl
+
+app/install-dev:
+	cd $(APP_PKG_DIR) && uv pip install -e .
+
+endif # APPPY_APP_MK_INCLUDED

apppy_app-0.1.0/pyproject.toml

@@ -0,0 +1,35 @@
+[build-system]
+requires = ["hatchling>=1.25"]
+build-backend = "hatchling.build"
+
+[project]
+name = "apppy-app"
+version = "0.1.0"
+description = "Application definitions and infrastructure for server development"
+readme = "README.md"
+requires-python = ">=3.11"
+license = {text = "MIT"}
+authors = [{ name = "Tim Kral" }]
+classifiers = [
+  "Programming Language :: Python :: 3",
+  "License :: OSI Approved :: MIT License",
+]
+dependencies = [
+    "apppy-auth>=0.1.0",
+    "apppy-db>=0.1.0",
+    "apppy-env>=0.1.0",
+    "apppy-fastql>=0.1.0",
+    "apppy-logger>=0.1.0",
+    "click==8.2.1",
+    "dependency-injector==4.48.1",
+    "fastapi==0.115.14",
+    "fastapi-lifespan-manager==0.1.4",
+    "strawberry-graphql[fastapi]==0.275.5",
+    "uvicorn==0.35.0"
+]
+
+[project.urls]
+Homepage = "https://github.com/spals/apppy"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/apppy"]

apppy_app-0.1.0/src/apppy/app/__init__.py

@@ -0,0 +1,256 @@
+import logging
+import subprocess
+import sys
+import typing
+from typing import Any
+
+import uvicorn
+from dependency_injector import containers, providers
+from fastapi import FastAPI
+from fastapi_lifespan_manager import LifespanManager
+
+from apppy.app.context import (
+    create_context_authenticated,
+    create_context_unauthenticated,
+)
+from apppy.app.health import DefaultHealthCheck, HealthApi, HealthCheck
+from apppy.app.middleware import (
+    JwtAuthMiddleware,
+    RequestIdMiddleware,
+    SessionMiddleware,
+    SessionMiddlewareSettings,
+)
+from apppy.app.version import VersionQuery, VersionSettings
+from apppy.auth.jwks import JwksAuthStorage, JwksAuthStorageSettings
+from apppy.auth.jwt import JwtAuthSettings
+from apppy.auth.oauth import OAuthRegistry, OAuthRegistrySettings
+from apppy.db.migrations import DefaultMigrations, Migrations
+from apppy.db.postgres import PostgresClient, PostgresClientSettings
+from apppy.env import Env
+from apppy.fastql import FastQL
+from apppy.fastql.typed_id import TypedIdEncoder, TypedIdEncoderSettings
+from apppy.fs import FileSystem, FileSystemSettings
+from apppy.fs.local import LocalFileSystem, LocalFileSystemSettings
+from apppy.logger import bootstrap_global_logging
+
+_logger = logging.getLogger("apppy.app.App")
+
+
+def _noop_provider(*args: Any, **kwargs: Any) -> None:
+    return None
+
+
+class App(containers.DeclarativeContainer):
+    """
+    A conceptual representation of the application. This includes:
+
+    - A reference to the configuration environment
+    - A reference to the application container
+    """
+
+    ##### Basic Application #####
+    env: providers.Dependency[Env] = providers.Dependency()
+    fastapi: providers.Dependency[FastAPI] = providers.Dependency()
+    fastql: providers.Provider[FastQL] = providers.Object(FastQL())
+    lifespan: providers.Provider[LifespanManager] = providers.Object(LifespanManager())
+
+    # Typed Ids
+    typed_id_encoder_settings: providers.Provider[TypedIdEncoderSettings] = providers.Singleton(
+        TypedIdEncoderSettings, env=env
+    )
+    typed_id_encoder: providers.Provider[TypedIdEncoder] = providers.Singleton(
+        TypedIdEncoder, settings=typed_id_encoder_settings
+    )
+
+    ##### Core Application Systems #####
+    # FileSystem
+    fs_settings: providers.Provider[FileSystemSettings] = providers.Singleton(
+        FileSystemSettings, env=env
+    )
+    fs: providers.Provider[FileSystem] = providers.Singleton(FileSystem, settings=fs_settings)
+    fs_local_settings: providers.Provider[LocalFileSystemSettings] = providers.Singleton(
+        LocalFileSystemSettings, env=env
+    )
+    fs_local: providers.Provider[LocalFileSystem] = providers.Singleton(
+        LocalFileSystem, settings=fs_local_settings, fs=fs
+    )
+
+    ##### Microservice: Auth #####
+    jwt_auth_settings: providers.Provider[JwtAuthSettings] = providers.Singleton(
+        JwtAuthSettings, env=env
+    )
+    jwks_auth_storage_settings: providers.Provider[JwksAuthStorageSettings] = providers.Singleton(
+        JwksAuthStorageSettings, env=env
+    )
+    jwks_auth_storage: providers.Provider[JwksAuthStorage] = providers.Singleton(
+        JwksAuthStorage, settings=jwks_auth_storage_settings, lifespan=lifespan, fs=fs
+    )
+
+    oauth_registry_settings: providers.Provider[OAuthRegistrySettings] = providers.Singleton(
+        OAuthRegistrySettings, env=env
+    )
+    oauth_registry: providers.Provider[OAuthRegistry] = providers.Singleton(
+        OAuthRegistry, settings=oauth_registry_settings
+    )
+
+    session_middleware_settings = providers.Singleton(SessionMiddlewareSettings, env=env)
+
+    ##### Microservice: Database #####
+    migrations: providers.Provider[Migrations] = providers.Singleton(DefaultMigrations)
+
+    postgres_settings: providers.Provider[PostgresClientSettings] = providers.Singleton(
+        PostgresClientSettings, env=env
+    )
+    postgres: providers.Provider[PostgresClient] = providers.Singleton(
+        PostgresClient, settings=postgres_settings, lifespan=lifespan
+    )
+
+    ##### Microservice: Health #####
+    health_check: providers.Provider[HealthCheck] = providers.Singleton(DefaultHealthCheck)
+
+    health_api: providers.Provider[HealthApi] = providers.Singleton(
+        HealthApi, fastapi=fastapi, health_check=health_check
+    )
+
+    ##### Microservice: Version #####
+    version_settings: providers.Provider[VersionSettings] = providers.Singleton(
+        VersionSettings, env=env
+    )
+    version_query = providers.Singleton(
+        VersionQuery,
+        settings=version_settings,
+        fastql=fastql,
+        migrations=migrations,
+    )
+
+    # Setup services which are attached to an API, which
+    # means that they will not have a chance to be otherwise
+    # instantiated.
+    setup_global_services = providers.Callable(_noop_provider)
+    # This registers all necessary middleware.
+    register_middleware = providers.Callable(_noop_provider)
+    # This registers all externally facing GraphQL operations.
+    register_graphql_operations = providers.Callable(_noop_provider)
+    # This registers all externally facing REST API routes.
+    register_rest_routes = providers.Callable(_noop_provider)
+
+    @classmethod
+    def create(
+        cls,
+        fastapi_fn: typing.Callable[[LifespanManager], FastAPI] | None = None,
+        inject_auth: bool = True,
+        **kwargs,
+    ) -> "App":
+        # We can pass an environment in one of two ways
+        # Either a pre-created environment object, or
+        # a name of an environment to load.
+        if "env" in kwargs:
+            env = kwargs["env"]
+        else:
+            # TODO: Environment overrides
+            env = Env.load(prefix=kwargs.get("env_prefix", "APP"), name=kwargs["env_name"])
+
+        bootstrap_global_logging(kwargs.get("log_level", logging.INFO))
+        _logger.info("Creating application", extra=kwargs)
+        app: App = cls()
+        app.env.override(providers.Object(env))
+
+        if fastapi_fn is not None:
+            fastapi: FastAPI = fastapi_fn(app.lifespan())
+        else:
+            fastapi = FastAPI(lifespan=app.lifespan())
+        app.fastapi.override(providers.Object(fastapi))
+
+        _logger.info("Assembling application")
+        TypedIdEncoder.set_global(app.typed_id_encoder())
+        app.health_api()  # Register a health API with each application
+        app.version_query()  # Register a version API with each application
+
+        app.fastapi().add_middleware(
+            RequestIdMiddleware
+        )  # Register a request id middleware with each application
+
+        # Run hook for individual applications to
+        # set up their custom global services
+        app.setup_global_services(app)
+        if inject_auth is True:
+            # We'll instantiate the local file system here
+            # to allow for the jwks auth storage to work.
+            # However, in production application should use
+            # a more robust filesystem (e.g. S3 or Supabase)
+            app.fs_local()
+            # Pre-build the jwks auth service. Note that we load
+            # this singleton for service GraphQL requests but we
+            # would like the constructor to be run beforehand here
+            # NOTE: This needs to come after the FileSystem
+            app.jwks_auth_storage()
+
+            app.fastapi().add_middleware(
+                JwtAuthMiddleware,
+                jwt_auth_settings=app.jwt_auth_settings(),
+                jwks_auth_storage=app.jwks_auth_storage(),
+            )
+            app.fastapi().add_middleware(
+                SessionMiddleware, settings=app.session_middleware_settings()
+            )
+
+        # Run hook for individual applications to
+        # set up their custom middleware and APIs
+        app.register_middleware(app)
+        app.register_graphql_operations(app)
+        app.register_rest_routes(app)
+
+        _logger.info("Including graphql router in FastAPI")
+        fastapi.include_router(
+            router=app.fastql().create_router(
+                context_getter=(
+                    create_context_authenticated if inject_auth else create_context_unauthenticated
+                ),
+                graphiql=(not app.env().is_production),
+            ),
+        )
+
+        return app
+
+    @classmethod
+    def create_debug_fastapi(cls) -> "FastAPI":
+        # NOTE: A uvicorn factory must be completely self-contained with
+        # no runtime configuration. Therefore, we just have to assume
+        # that we're running in debug mode and that we're in a local environment.
+        app: App = cls.create(
+            **{"env_name": "local", "log_level": logging.DEBUG},  # type: ignore[arg-type]
+        )
+        return app.fastapi()
+
+    @classmethod
+    def run(cls, debug: bool = False, **kwargs) -> None:
+        if debug:
+            # When in debug using hot reloads, we have to launch asubprocess
+            cmd = [
+                sys.executable,  # python interpreter
+                "-m",
+                "uvicorn",
+                f"{cls.__module__}:{cls.__name__}.create_debug_fastapi",
+                "--factory",
+                "--host",
+                "0.0.0.0",
+                "--log-level",
+                kwargs.get("log_level", "debug"),
+                "--port",
+                str(kwargs.get("port", 8000)),
+                "--reload",
+                "--reload-dir",
+                "application",
+            ]
+            subprocess.run(cmd, check=True)
+        else:
+            app: App = cls.create(**kwargs)
+            uvicorn_config = uvicorn.Config(
+                app=app.fastapi(),
+                host="0.0.0.0",
+                log_level=kwargs.get("log_level", "info"),
+                port=kwargs.get("port", 8000),
+                reload=False,
+            )
+            uvicorn_server = uvicorn.Server(uvicorn_config)
+            uvicorn_server.run()

apppy_app-0.1.0/src/apppy/app/cli.py

@@ -0,0 +1,305 @@
+from __future__ import annotations
+
+import re
+import sys
+from typing import TypeVar
+
+import anyio
+import click
+
+from apppy.app import App
+from apppy.fastql import FastQL
+
+A = TypeVar("A", bound=App)
+
+
+def make_app_cli(
+    app_type: type[A],
+    *,
+    app_name: str,
+    default_port: int = 8000,
+) -> click.Group:
+    def _create_and_run_app(debug: bool, **kwargs) -> None:
+        try:
+            app_type.run(debug, **kwargs)
+        except KeyboardInterrupt:
+            # Gracefully shutdown on keyboard interrupt
+            sys.exit(0)
+
+    @click.group(name="run", help=f"Run an instance of the {app_name} server")
+    def group() -> None:
+        pass
+
+    @group.command("check-server")
+    def check_server():
+        """Construct an instance of the application.
+
+        This will help determine if there's a configuration issue.
+        It is useful to run ahead of integration testing.
+        """
+        kwargs = {
+            "env_name": "ci",
+            "log_level": "debug",
+        }
+
+        app_instance = app_type.create(**kwargs)
+        assert app_instance is not None
+
+        # Simulate the asynchronous part of the app startup
+        async def _async_app_startup():
+            async with app_instance.fastapi().router.lifespan_context(app_instance.fastapi()):
+                pass
+
+        anyio.run(_async_app_startup)
+
+    @group.command("run-debug")
+    @click.option(
+        "--port",
+        required=False,
+        default=default_port,
+        type=click.INT,
+        help="The port on which to run the application",
+    )
+    def server_debug(port: int):
+        """Run an instance of the application in a local environment in full debug mode"""
+
+        kwargs = {
+            "env_name": "local",
+            "log_level": "debug",
+            "port": port,
+        }
+        # NOTE: This is slightly different from the --debug flags below
+        # as this will create a fully hot-reloadable server using only
+        # default values whereas the --debug flags setup debug mode for
+        # the server is the specified environment.
+        _create_and_run_app(debug=True, **kwargs)
+
+    @group.command("run-local")
+    @click.option(
+        "--port",
+        required=False,
+        default=default_port,
+        type=click.INT,
+        help="The port on which to run the application",
+    )
+    def server_local(port: int):
+        """Run an instance of the application in a local environment"""
+        """Run the app in a local environment."""
+        kwargs = {
+            "env_name": "local",
+            "log_level": "debug",
+            "port": port,
+        }
+        _create_and_run_app(debug=False, **kwargs)
+
+    @group.command("run-server")
+    @click.option(
+        "--debug",
+        required=False,
+        default=False,
+        is_flag=True,
+        type=click.BOOL,
+        help="Enable debug mode",
+    )
+    @click.option(
+        "--port",
+        required=False,
+        default=default_port,
+        type=click.INT,
+        help="The port on which to run the application",
+    )
+    def server(debug: bool, port: int):
+        """Run an instance of the application.
+
+        This does not force any particular environment, but
+        rather reads it from the APP_ENV (or equivalent) environment variable.
+        """
+        kwargs = {
+            "log_level": "debug" if debug else "info",
+            "port": port,
+        }
+        _create_and_run_app(debug=False, **kwargs)
+
+    def _reorder_schema(schema_content: str) -> str:
+        # HACK: We need to reorder the schema definition a little
+        # bit in order for some of the codegen tools to work correctly
+        # Unfortunately, the native print_schema utility in Strawberry
+        # does not allow this so we have to do it here.
+
+        # CASE: More GraphQLError interface to the top
+        pattern = r"(interface GraphQLError\s+{[^}]+})"
+        match = re.search(pattern, schema_content)
+        if match:
+            definition = match.group(1)
+            schema_content = schema_content.replace(definition, "")
+            return f"{definition}\n\n{schema_content}"
+
+        return schema_content
+
+    @group.command("graphql-gen")
+    @click.argument(
+        "base_dir",
+        required=True,
+        default=f"graphql/__generated__/{app_name}",
+        type=click.Path(file_okay=False, dir_okay=True, writable=True),
+    )
+    @click.option(
+        "--include-fragments",
+        default=False,
+        required=True,
+        is_flag=True,
+        help="Generate GraphQL fragment files",
+    )
+    @click.option(
+        "--include-mutations",
+        default=False,
+        required=True,
+        is_flag=True,
+        help="Generate GraphQL mutation files",
+    )
+    @click.option(
+        "--include-queries",
+        default=False,
+        required=True,
+        is_flag=True,
+        help="Generate GraphQL query files",
+    )
+    @click.option(
+        "--include-schema",
+        default=False,
+        required=True,
+        is_flag=True,
+        help="Generate GraphQL schema file",
+    )
+    @click.option(
+        "--schema-file",
+        default=f"{app_name}.schema.graphql",
+        required=True,
+        type=click.Path(file_okay=True, dir_okay=False, writable=True),
+    )
+    def graphql_gen(
+        base_dir: str,
+        include_fragments: bool,
+        include_mutations: bool,
+        include_queries: bool,
+        include_schema: bool,
+        schema_file: str,
+    ):
+        """Auto-generate GraphQL files"""
+
+        # NOTE: All Graphql generation happens in this one function
+        # to avoid having to load the FastQL instance multiple times
+
+        kwargs = {
+            "env_name": "ci",
+            "log_level": "warning",
+        }
+        app_instance = app_type.create(**kwargs)
+        fastql: FastQL = app_instance.fastql()
+
+        if include_fragments:
+            fragments: dict[str, str] = {}
+            types_visited: set[str] = set()
+
+            for typename, _ in fastql.types_output_metadata:
+                fastql.collect_and_print_fragments(typename, types_visited, fragments)
+
+            for typename, _ in fastql.types_error_metadata:
+                fastql.collect_and_print_fragments(typename, types_visited, fragments)
+
+            fragment_header = (
+                "# This fragment file is automatically generated. DO NOT EDIT MANUALLY.\n"
+                "# To update, run make gql or make gql-gen or make gql-fragments.\n\n"
+            )
+
+            for name, content in fragments.items():
+                fastql.write_graphql_file(
+                    base_dir=f"{base_dir}/fragments",
+                    file_name=f"{name}Fragment.graphql",
+                    file_content=content,
+                    file_header=fragment_header,
+                )
+
+            click.secho(
+                f"✅ Generated {len(fragments)} fragment file(s) in '{base_dir}/fragments'",
+                fg="green",
+            )
+
+        if include_mutations:
+            if not include_fragments:
+                click.secho(
+                    "Unable to generate mutations without --include-fragments",
+                    fg="red",
+                )
+                sys.exit(1)
+
+            mutations: dict[str, str] = {}
+            mutations_visited: set[str] = set()
+
+            mutation_header = (
+                "# This mutation file is automatically generated. DO NOT EDIT MANUALLY.\n"
+                "# To update, run make gql or make gql-gen or make gql-mutations.\n\n"
+            )
+            for m in fastql.mutations_raw:
+                fastql.collect_and_print_mutations(type(m).__name__, mutations_visited, mutations)
+
+            for name, content in mutations.items():
+                fastql.write_graphql_file(
+                    base_dir=f"{base_dir}/mutations",
+                    file_name=f"{name}.graphql",
+                    file_content=content,
+                    file_header=mutation_header,
+                )
+
+            click.secho(
+                f"✅ Generated {len(mutations)} mutation file(s) in '{base_dir}/mutations'",
+                fg="green",
+            )
+
+        if include_queries:
+            if not include_fragments:
+                click.secho(
+                    "Unable to generate queries without --include-fragments",
+                    fg="red",
+                )
+                sys.exit(1)
+
+            queries: dict[str, str] = {}
+            queries_visited: set[str] = set()
+
+            query_header = (
+                "# This query file is automatically generated. DO NOT EDIT MANUALLY.\n"
+                "# To update, run make gql or make gql-gen or make gql-queries.\n\n"
+            )
+            for q in fastql.queries_raw:
+                fastql.collect_and_print_queries(type(q).__name__, queries_visited, queries)
+
+            for name, content in queries.items():
+                fastql.write_graphql_file(
+                    base_dir=f"{base_dir}/queries",
+                    file_name=f"{name}.graphql",
+                    file_content=content,
+                    file_header=query_header,
+                )
+
+            click.secho(
+                f"✅ Generated {len(queries)} query file(s) in '{base_dir}/queries'",
+                fg="green",
+            )
+
+        if include_schema:
+            schema_header = (
+                "# This schema file is automatically generated. DO NOT EDIT MANUALLY.\n"
+                "# To update, run make gql or make gql-gen or make gql-schema.\n\n"
+            )
+            schema_content = fastql.print_schema()
+            schema_content = _reorder_schema(schema_content)
+            fastql.write_graphql_file(
+                base_dir=f"{base_dir}/schema",
+                file_name=schema_file,
+                file_content=schema_content,
+                file_header=schema_header,
+            )
+            click.secho(f"✅ Generated schema file '{base_dir}/schema/{schema_file}'", fg="green")
+
+    return group

apppy_app-0.1.0/src/apppy/app/context.py

@@ -0,0 +1,27 @@
+from dataclasses import dataclass
+
+from fastapi import Request
+from strawberry.fastapi.context import BaseContext
+
+from apppy.auth.jwt import JwtAuthContext
+
+
+@dataclass
+class UnauthenticatedAppContext(BaseContext):
+    request: Request
+
+
+def create_context_unauthenticated(request: Request) -> UnauthenticatedAppContext:
+    return UnauthenticatedAppContext(request=request)
+
+
+@dataclass
+class AuthenticatedAppContext(BaseContext):
+    auth: JwtAuthContext
+    request: Request
+
+
+def create_context_authenticated(request: Request) -> AuthenticatedAppContext:
+    # NOTE: The current JwtAuthContext is set in JwtAuthMiddleware
+    auth_ctx: JwtAuthContext = JwtAuthContext.current_auth_context()
+    return AuthenticatedAppContext(auth=auth_ctx, request=request)

apppy_app-0.1.0/src/apppy/app/health.py

@@ -0,0 +1,38 @@
+import abc
+
+from fastapi import APIRouter, FastAPI
+
+from apppy.logger import WithLogger
+
+
+class HealthCheck(abc.ABC):
+    @abc.abstractmethod
+    def health_check(self) -> bool:
+        pass
+
+    def ping(self) -> str:
+        return "ok"
+
+
+class DefaultHealthCheck(HealthCheck):
+    def health_check(self) -> bool:
+        return True
+
+
+class HealthApi(WithLogger):
+    def __init__(self, fastapi: FastAPI, health_check: HealthCheck):
+        self._health_check: HealthCheck = health_check
+        fastapi.include_router(self.__create_router())
+
+    def __create_router(self) -> APIRouter:
+        router = APIRouter()
+
+        @router.get("/health/check")
+        async def health_check():
+            return {"healthy", self._health_check.health_check()}
+
+        @router.get("/health/ping")
+        async def health_ping():
+            return {"ping": self._health_check.ping()}
+
+        return router

apppy_app-0.1.0/src/apppy/app/middleware.py

@@ -0,0 +1,113 @@
+import uuid
+from contextlib import suppress
+
+from fastapi import BackgroundTasks, FastAPI, Request
+from fastapi_another_jwt_auth import AuthJWT as JWT
+from pydantic import Field
+from starlette.middleware.base import BaseHTTPMiddleware as StarletteHTTPMiddleware
+from starlette.middleware.sessions import SessionMiddleware as StarletteSessionMiddleware
+
+from apppy.auth.errors.service import (
+    ServiceKeyAlgorithmMissingError,
+)
+from apppy.auth.jwks import JwkInfo, JwksAuthStorage
+from apppy.auth.jwt import JwtAuthContext, JwtAuthSettings
+from apppy.env import EnvSettings
+from apppy.fastql.errors import GraphQLError
+from apppy.logger.storage import LoggingStorage
+
+
+class JwtAuthMiddleware(StarletteHTTPMiddleware):
+    """
+    A middleware instance which analyzes the request headers,
+    creates a JwtAuthContext, and set it in thread local storage
+    """
+
+    def __init__(
+        self,
+        fastapi: FastAPI,
+        jwt_auth_settings: JwtAuthSettings,
+        jwks_auth_storage: JwksAuthStorage,
+    ):
+        super().__init__(app=fastapi)
+        self._jwks_auth_storage = jwks_auth_storage
+
+        # Load the global JWT configuration JWT.
+        # This is used for processing user requests below.
+        @JWT.load_config
+        def load_config_jwtauth_global():
+            return jwt_auth_settings
+
+    async def dispatch(self, request: Request, call_next):
+        jwt_headers: dict | None = JwtAuthContext.peek(request)
+
+        try:
+            if jwt_headers is not None and "kid" in jwt_headers:
+                # CASE: A Service is making the request
+                jwk_info: JwkInfo = self._jwks_auth_storage.get_jwk(jwt_headers["kid"])
+
+                if "alg" not in jwt_headers:
+                    raise ServiceKeyAlgorithmMissingError()
+
+                public_key = jwk_info.jwk.get_op_key("verify")
+                auth_ctx = JwtAuthContext.from_service_request(
+                    request, jwt_headers["alg"], public_key
+                )
+            else:
+                # CASE: A User is making the request
+                # Instead of using the JWKS storage, we'll
+                # use the global configuration loaded in __init__
+                auth_ctx = JwtAuthContext.from_user_request(request)
+        except GraphQLError as e:
+            # If we encounter an error while preprocessing the
+            # auth context, we'll capture the error and keep going. The
+            # authentication and authorization permission are designed
+            # to handle this and raise the appropriate error.
+            auth_ctx = JwtAuthContext(preprocessing_error=e)
+
+        JwtAuthContext.set_current_auth_context(auth_ctx)
+        response = await call_next(request)
+        return response
+
+
+class RequestIdMiddleware(StarletteHTTPMiddleware):
+    def __init__(self, fastapi: FastAPI, header_name: str = "X-Request-ID"):
+        super().__init__(fastapi)
+        self.header_name = header_name
+
+    async def dispatch(self, request: Request, call_next):
+        request_id = str(uuid.uuid4())
+
+        # Store in LoggingStorage (thread-local)
+        with suppress(RuntimeError):
+            LoggingStorage.get_global().add_request_id(request_id)
+
+        response = await call_next(request)
+
+        # Cleanup after the response has been sent
+        def cleanup_logging_storage():
+            with suppress(RuntimeError):
+                LoggingStorage.get_global().reset()
+
+        # Ensure background task manager exists
+        if response.background is None:
+            response.background = BackgroundTasks()
+
+        response.background.add_task(cleanup_logging_storage)
+        response.headers.setdefault(self.header_name, request_id)
+
+        return response
+
+
+class SessionMiddlewareSettings(EnvSettings):
+    secret_key: str = Field(alias="APP_SESSION_MIDDLEWARE_SECRET_KEY", exclude=True)
+
+
+class SessionMiddleware(StarletteSessionMiddleware):
+    """
+    Simple wrapper around Starlette's SessionMiddleware to allow for
+    injected settings via EnvSettings
+    """
+
+    def __init__(self, fastapi: FastAPI, settings: SessionMiddlewareSettings):
+        super().__init__(app=fastapi, secret_key=settings.secret_key)

apppy_app-0.1.0/src/apppy/app/version.py

@@ -0,0 +1,43 @@
+from dataclasses import dataclass
+
+import strawberry
+from pydantic import Field
+
+from apppy.db.migrations import Migrations
+from apppy.env import EnvSettings
+from apppy.fastql import FastQL
+from apppy.fastql.annotation import fastql_query, fastql_query_field, fastql_type_output
+from apppy.logger import WithLogger
+
+
+class VersionSettings(EnvSettings):
+    commit: str = Field(alias="APP_VERSION_COMMIT", default="local")
+    release: str = Field(alias="APP_VERSION_RELEASE", default="local")
+
+
+@dataclass
+@fastql_type_output
+class VersionApiOutput:
+    commit: str
+    migration: str | None
+    release: str
+
+
+@fastql_query()
+class VersionQuery(WithLogger):
+    def __init__(self, settings: VersionSettings, fastql: FastQL, migrations: Migrations) -> None:
+        self._settings = settings
+        self._migrations = migrations
+        fastql.include_in_schema(self)
+
+    @fastql_query_field(
+        skip_permission_checks=True,
+    )
+    async def version(self, info: strawberry.Info) -> VersionApiOutput:
+        version_output = VersionApiOutput(
+            commit=self._settings.commit,
+            migration=(await self._migrations.head()),
+            release=self._settings.release,
+        )
+
+        return version_output