hexcore 11.2.0__tar.gz → 11.4.0__tar.gz

{hexcore-11.2.0/hexcore.egg-info → hexcore-11.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hexcore
-Version: 11.2.0
+Version: 11.4.0
 Summary: Reusable core for Python projects with hexagonal architecture, DDD, CQRS and background tasks. Ships the abstractions and the infrastructure: SQL session layer, FastAPI factories, worker runner, dynamic cron and identity.
 Author-email: "David Latosefki (Indroic)" <indroic@outlook.com>
 License-Expression: MIT

{hexcore-11.2.0 → hexcore-11.4.0}/hexcore/config.py

@@ -78,6 +78,26 @@ class ServerConfig(BaseModel):
     allow_methods: list[str] = ["*"]
     allow_headers: list[str] = ["*"]
 
+    # CORS para una SPA en otro origen con la cookie de sesión. Los tres van con el prefijo
+    # `cors_` porque `max_age` y `expose_headers` a secas, en una config que también tiene
+    # cookies y TTLs, se leen como otra cosa.
+    #
+    # `cors_origin_predicate` cubre los orígenes que `allow_origins` no puede enumerar —un
+    # subdominio por tenant creado en caliente—, igual que
+    # `IdentityConfig.trusted_origin_predicate` hace con el CSRF. **Se suma** a `allow_origins`,
+    # no lo reemplaza. Es síncrono, recibe el origen tal cual llega en el header `Origin`
+    # (`"https://a.ejemplo.com"`) y si lanza se trata como «no confiable».
+    #
+    # `cors_expose_headers`: las cabeceras de la respuesta que el JS puede leer entre orígenes.
+    # Sin declararlas, el navegador sólo deja leer las «seguras» (`Content-Type`, etc.).
+    #
+    # `cors_max_age`: cuántos segundos el navegador cachea el preflight. Sin caché, toda
+    # escritura JSON con un header propio (`X-CSRF-Token`) cuesta un `OPTIONS` previo. 600 es el
+    # default de Starlette; Chrome topea en 7200.
+    cors_origin_predicate: t.Callable[[str], bool] | None = None
+    cors_expose_headers: list[str] = Field(default_factory=list)
+    cors_max_age: int = Field(default=600, ge=0)
+
     # caching
     cache_backend: ICache = (
         MemoryCache()
@@ -171,6 +191,9 @@ class ServerConfig(BaseModel):
         1. Si no pasaste `allow_origins`, se completa: en `debug` queda `["*"]` (comodidad
            de desarrollo, que era la intención original), y fuera de `debug` queda
            `["http://localhost:<port>"]`. Un valor explícito —incluso `[]`— se respeta.
+           **Con un `cors_origin_predicate` declarado queda `[]`**: el predicado es la lista, y
+           derivar `["*"]` bajaría `allow_credentials` a `False` en silencio y las cookies
+           dejarían de funcionar sin que nadie lo pidiera.
         2. **`"*"` con `allow_credentials=True` nunca es válido, y el invariante vale
            siempre, no sólo fuera de `debug`.** Es que `debug` viene en `True` por
            defecto, así que condicionarlo al entorno dejaba la combinación peligrosa
@@ -194,9 +217,12 @@ class ServerConfig(BaseModel):
         lo_pidio_el_usuario = "allow_origins" in self.model_fields_set
 
         if not lo_pidio_el_usuario and not self.allow_origins:
-            self.allow_origins = (
-                ["*"] if self.debug else [f"http://localhost:{self.port}"]
-            )
+            if self.cors_origin_predicate is not None:
+                self.allow_origins = []
+            else:
+                self.allow_origins = (
+                    ["*"] if self.debug else [f"http://localhost:{self.port}"]
+                )
 
         if "*" not in self.allow_origins or not self.allow_credentials:
             return self

{hexcore-11.2.0 → hexcore-11.4.0}/hexcore/darwin/application/services.py

@@ -381,6 +381,20 @@ class SessionService:
             impersonation=impersonacion,
         )
 
+    async def previous_session_ids(self, session_id: UUID, *, limit: int = 100) -> list[UUID]:
+        """
+        Los `sid` de las sesiones **anteriores** de la familia de `session_id` (sin incluirla).
+
+        Existe para que `CsrfMiddleware` reconozca un token anti-CSRF que fue válido para la
+        sesión que el refresh acaba de reemplazar. Lee la base, pero sólo en el camino de
+        rechazo y con tope: el camino feliz de un request no lo llama.
+        """
+        sesion = await self._sessions.get(session_id)
+        if sesion is None:
+            return []
+        ids = await self._sessions.list_family_session_ids(sesion.family_id, limit=limit)
+        return [sid for sid in ids if sid != session_id]
+
     # ── Rotar ─────────────────────────────────────────────────────────────────
     async def refresh(
         self, refresh_token: str, *, transport: Transport

{hexcore-11.2.0 → hexcore-11.4.0}/hexcore/darwin/domain/exceptions.py

@@ -36,6 +36,8 @@ __all__ = [
     "EmailNotVerifiedError",
     "ImpersonationNotPermittedError",
     "CsrfValidationError",
+    "CSRF_CODE_INVALID",
+    "CSRF_CODE_PREVIOUS_SESSION",
     # ── Estado (409 / 423) ──
     "EmailAlreadyRegisteredError",
     "UsernameAlreadyTakenError",
@@ -164,14 +166,35 @@ class ImpersonationNotPermittedError(AuthorizationError):
     """
 
 
+#: `code` de un rechazo de CSRF cuyo token no verifica contra la sesión en curso ni contra
+#: ninguna anterior de su familia: lo mandó alguien que no lo recibió del servidor.
+CSRF_CODE_INVALID = "CsrfTokenInvalid"
+
+#: `code` de un rechazo de CSRF cuyo token **sí** fue válido, pero de una sesión anterior de la
+#: misma familia de rotación: el cliente firmó antes de que un refresh rotara el `sid`. Es el
+#: caso que se arregla pidiendo el token vigente (`GET /auth/csrf`) y reintentando.
+CSRF_CODE_PREVIOUS_SESSION = "CsrfTokenFromPreviousSession"
+
+
 class CsrfValidationError(AuthorizationError):
     """
     Falló el chequeo anti-CSRF del transporte por cookie.
 
     Sólo aplica al camino de cookie: un cliente Bearer manda el token a propósito en cada
     petición, así que no hay nada que falsificar desde otro origen.
+
+    `code` distingue, **cuando el rechazo es por el token**, entre `CSRF_CODE_INVALID` y
+    `CSRF_CODE_PREVIOUS_SESSION`; viaja en el cuerpo del 403 junto a `error`
+    (`CsrfValidationError`, que sigue siendo el discriminante). Es `None` cuando el rechazo
+    no es por el token (un origen en el que no se confía), porque ahí no hay nada que
+    recuperar. No revela nada útil a un atacante: sólo se llega a `CSRF_CODE_PREVIOUS_SESSION`
+    mandando un token que el servidor ya emitió para esa misma familia de sesiones.
     """
 
+    def __init__(self, *args: object, code: str | None = None) -> None:
+        super().__init__(*args)
+        self.code = code
+
 
 # ── Estado del recurso ────────────────────────────────────────────────────────
 class EmailAlreadyRegisteredError(IdentityError):

{hexcore-11.2.0 → hexcore-11.4.0}/hexcore/darwin/domain/ports.py

@@ -187,6 +187,26 @@ class AbstractSessionRepository(abc.ABC):
     async def revoke(self, session_id: UUID, *, at: datetime, reason: str) -> None:
         raise NotImplementedError
 
+    async def list_family_session_ids(
+        self, family_id: UUID, *, limit: int = 100
+    ) -> "list[UUID]":
+        """
+        Los `id` de las sesiones de una familia de rotación, las **más recientes primero**, con
+        tope de `limit`.
+
+        Sólo lo usa `CsrfMiddleware` para clasificar un rechazo de CSRF: reconocer que el token
+        que llegó era de una sesión anterior de la familia (el cliente firmó antes de que un
+        refresh rotara el `sid`). Incluye revocadas y consumidas: justamente las anteriores lo
+        están.
+
+        **No es abstracto a propósito**: es un puerto agregado después, y volverlo abstracto
+        rompería a todo repositorio propio ya escrito. La implementación por defecto devuelve
+        `[]`, y entonces el rechazo se clasifica siempre como token inválido: el comportamiento
+        (403) no cambia, sólo se pierde el `code` más específico.
+        """
+        del family_id, limit
+        return []
+
     @abc.abstractmethod
     async def revoke_family(self, family_id: UUID, *, at: datetime, reason: str) -> int:
         """

{hexcore-11.2.0 → hexcore-11.4.0}/hexcore/darwin/infrastructure/api/dependencies.py

@@ -194,13 +194,17 @@ def identity_exception_payload(exc: Exception) -> t.Mapping[str, t.Any]:
     Darwin) devuelve sólo lo del núcleo en vez de lanzar — mismo trato que `_mapa_de_plugins()`
     en `app.py`.
     """
-    from hexcore.darwin.domain.exceptions import AccessDeniedError
+    from hexcore.darwin.domain.exceptions import AccessDeniedError, CsrfValidationError
 
     base: dict[str, t.Any] = {}
     if isinstance(exc, AccessDeniedError):
         # Sólo `required`: `Decision.reason` es interno y nunca llega al cliente. Ver el
         # docstring de `AccessDeniedError`.
         base["required"] = exc.required
+    elif isinstance(exc, CsrfValidationError) and exc.code is not None:
+        # El mismo `code` que `CsrfMiddleware` pone en su 403, para que un rechazo de CSRF
+        # lanzado desde un handler tenga la misma forma que el del middleware.
+        base["code"] = exc.code
 
     from hexcore.darwin.application.container import get_identity_container
 

{hexcore-11.2.0 → hexcore-11.4.0}/hexcore/darwin/infrastructure/api/middlewares.py

@@ -25,7 +25,12 @@ from starlette.requests import Request
 from starlette.responses import JSONResponse, Response
 
 from hexcore.darwin.domain.context import AUTH_CONTEXT
-from hexcore.darwin.domain.exceptions import CsrfValidationError, IdentityError
+from hexcore.darwin.domain.exceptions import (
+    CSRF_CODE_INVALID,
+    CSRF_CODE_PREVIOUS_SESSION,
+    CsrfValidationError,
+    IdentityError,
+)
 
 if t.TYPE_CHECKING:
     from hexcore.darwin.application.config import IdentityConfig
@@ -224,13 +229,74 @@ class CsrfMiddleware(BaseHTTPMiddleware):
             logger.info(
                 "CSRF rechazado en %s %s: %s", request.method, request.url.path, exc
             )
-            return JSONResponse(
-                status_code=403,
-                content={"detail": str(exc), "error": type(exc).__name__},
-            )
+            if exc.code == CSRF_CODE_INVALID and await self._es_de_sesion_anterior(
+                request, contenedor
+            ):
+                exc = CsrfValidationError(
+                    "El token anti-CSRF del header es de una sesión anterior: el refresh "
+                    "rotó la sesión después de que el cliente lo obtuvo. Pedí el vigente con "
+                    "`GET /auth/csrf` y repetí la petición.",
+                    code=CSRF_CODE_PREVIOUS_SESSION,
+                )
+            content: dict[str, t.Any] = {"detail": str(exc), "error": type(exc).__name__}
+            if exc.code is not None:
+                content["code"] = exc.code
+            return JSONResponse(status_code=403, content=content)
 
         return await call_next(request)
 
+    async def _es_de_sesion_anterior(
+        self, request: Request, contenedor: t.Any
+    ) -> bool:
+        """
+        Si el token del header fue el de una sesión **anterior de la misma familia** que la de
+        la cookie de acceso.
+
+        Sólo corre al rechazar, así que el camino feliz de un request no paga la lectura de la
+        base. Tiene que ser **mejor esfuerzo**: cualquier fallo (credencial que no autentica,
+        base caída, un backend sin `list_family_session_ids`) devuelve `False` y el rechazo
+        sale como token inválido, que es lo que habría salido sin esta clasificación. Nunca
+        convierte un 403 en un 500.
+        """
+        from hexcore.darwin.infrastructure.hashing import compare_hashes, derive_csrf_token
+
+        enviado = request.headers.get(CSRF_HEADER)
+        clave = contenedor.config.secret_key
+        if not enviado or clave is None:
+            return False
+
+        try:
+            auth = auth_from_request(request)
+            if auth is None:
+                from hexcore.darwin.infrastructure.transports import TransportResolver
+
+                transporte = TransportResolver(cookies=contenedor.config.cookies).resolve(
+                    request
+                )
+                token = transporte.extract_access(request)
+                if token is None:
+                    return False
+                auth = await contenedor.session_service().authenticate(
+                    token, transport=transporte.name
+                )
+
+            sid = getattr(auth.actor, "session_id", None)
+            if sid is None or auth.transport != "cookie":
+                return False
+
+            secreto = clave.get_secret_value()
+            previas = await contenedor.session_service().previous_session_ids(sid)
+            # Se recorren **todas** sin cortar en la primera que coincide: el tiempo no tiene
+            # que depender de cuál era (aunque `compare_hashes` ya es en tiempo constante).
+            coincide = False
+            for previa in previas:
+                if compare_hashes(enviado, derive_csrf_token(str(previa), secreto)):
+                    coincide = True
+            return coincide
+        except Exception:
+            logger.debug("No se pudo clasificar el rechazo de CSRF.", exc_info=True)
+            return False
+
     def _exento(self, request: Request) -> bool:
         if request.method.upper() in SAFE_METHODS:
             return True
@@ -262,14 +328,16 @@ class CsrfMiddleware(BaseHTTPMiddleware):
         if not enviado or not esperado:
             raise CsrfValidationError(
                 f"Falta el chequeo anti-CSRF: la petición tiene que mandar el header "
-                f"'{CSRF_HEADER}' con el mismo valor que la cookie de CSRF."
+                f"'{CSRF_HEADER}' con el mismo valor que la cookie de CSRF.",
+                code=CSRF_CODE_INVALID,
             )
 
         from hexcore.darwin.infrastructure.hashing import compare_hashes
 
         if not compare_hashes(enviado, esperado):
             raise CsrfValidationError(
-                "El valor anti-CSRF del header no coincide con el de la cookie."
+                "El valor anti-CSRF del header no coincide con el de la cookie.",
+                code=CSRF_CODE_INVALID,
             )
 
     @staticmethod

{hexcore-11.2.0 → hexcore-11.4.0}/hexcore/darwin/infrastructure/api/routers.py

@@ -31,6 +31,7 @@ from hexcore.darwin.infrastructure.api.dependencies import (
     provide_auth,
     require_not_impersonated,
 )
+from hexcore.darwin.infrastructure.api.middlewares import CSRF_HEADER
 
 if t.TYPE_CHECKING:
     from hexcore.darwin.application.config import IdentityConfig
@@ -42,6 +43,7 @@ __all__ = [
     "VerifyEmailRequest",
     "SignInRequest",
     "SessionResponse",
+    "CsrfTokenResponse",
     "MeResponse",
     "SignedOutResponse",
     "RevokedResponse",
@@ -122,6 +124,17 @@ class SignInRequest(BaseModel):
         return t.cast(str, self.identifier or self.email or self.username)
 
 
+class CsrfTokenResponse(BaseModel):
+    """
+    La respuesta de `GET /auth/csrf`: el valor anti-CSRF de la sesión en curso.
+
+    Es el mismo que trae la cookie de CSRF —`HMAC(secreto, sid)`, ver `derive_csrf_token`— y
+    que las respuestas que la emiten repiten en la cabecera `X-CSRF-Token`.
+    """
+
+    csrf_token: str
+
+
 class SessionResponse(BaseModel):
     """
     La respuesta de un sign-in o un refresh.
@@ -212,6 +225,14 @@ def emit_tokens(
     a propósito: el cliente tiene que poder leerla para devolverla en el header
     `X-CSRF-Token`. Que sea legible es lo que obliga a que su valor sea derivado del `sid` y
     no aleatorio — ver `derive_csrf_token`.
+
+    **Además va en la cabecera de la respuesta** (`X-CSRF-Token`, la misma que el cliente
+    devuelve en cada escritura). Una SPA en otro origen que la API —`app.ejemplo.com` contra
+    `api.ejemplo.com`— no puede leer esa cookie con `document.cookie`, porque pertenece al host
+    de la API: sin la cabecera no tiene de dónde sacar el valor, y toda escritura responde 403 sin
+    que nada apunte a la causa. La cabecera es legible cross-origin sólo si el CORS la expone
+    (`create_app` lo hace cuando `AppFeatures(csrf=True)`), o sea que no se la regala a un origen
+    que el CORS no permite; y el valor no sirve sin la cookie de sesión que el navegador ya tiene.
     """
     transport.emit(response, tokens)
 
@@ -234,15 +255,17 @@ def emit_tokens(
     #
     # El valor es un HMAC del `sid`, así que es válido mientras viva la sesión: alinearlo con
     # el refresh es lo coherente, y es el mismo número que la cookie de refresh.
+    valor = derive_csrf_token(str(tokens.session_id), clave.get_secret_value())
     response.set_cookie(
         config.cookies.name_for("csrf"),
-        derive_csrf_token(str(tokens.session_id), clave.get_secret_value()),
+        valor,
         max_age=int(config.tokens.refresh_ttl.total_seconds()),
         httponly=False,
         secure=config.cookies.secure,
         samesite=config.cookies.same_site,
         path=config.cookies.path,
     )
+    response.headers[CSRF_HEADER] = valor
 
 
 def session_response_body(
@@ -464,6 +487,44 @@ def build_identity_router(
         transport.clear(respuesta)
         return respuesta
 
+    @router.get("/csrf", response_model=CsrfTokenResponse)
+    async def csrf(
+        response: Response,
+        auth: "AuthContext[t.Any]" = Depends(provide_auth),
+    ) -> CsrfTokenResponse:
+        """
+        El valor anti-CSRF de la sesión por cookie en curso.
+
+        Para el cliente que **no puede leer la cookie de CSRF**: una SPA en otro origen que la
+        API (`document.cookie` sólo ve las cookies de su propio host). Lo pide al abrir la
+        página con una sesión ya existente y lo guarda **en memoria** — nunca en
+        `localStorage`—; el sign-in y el refresh lo entregan además en la cabecera
+        `X-CSRF-Token`, así que sólo hace falta acá cuando la página se recarga.
+
+        Es seguro darlo: sólo un origen que el CORS permita puede leer la respuesta, y el valor
+        no sirve sin la cookie de sesión que el navegador ya tiene. Es `HMAC(secreto, sid)`, el
+        mismo cálculo que `emit_tokens`.
+
+        **401 sin sesión por cookie.** Un cliente Bearer no hace CSRF —adjunta su token a
+        propósito— y pedirlo es un error de uso, no algo que haya que contestar.
+        """
+        from hexcore.darwin.application.container import get_identity_container
+        from hexcore.darwin.domain.exceptions import UnauthenticatedError
+        from hexcore.darwin.infrastructure.hashing import derive_csrf_token
+
+        config = get_identity_container().config
+        session_id = getattr(auth.actor, "session_id", None)
+        if auth.transport != "cookie" or session_id is None or config.secret_key is None:
+            raise UnauthenticatedError(
+                "El token anti-CSRF sólo existe para una sesión por cookie: un cliente Bearer "
+                "no hace CSRF."
+            )
+
+        response.headers["Cache-Control"] = "no-store"
+        return CsrfTokenResponse(
+            csrf_token=derive_csrf_token(str(session_id), config.secret_key.get_secret_value())
+        )
+
     @router.get("/me", response_model=MeResponse)
     async def me(auth: "AuthContext[t.Any]" = Depends(provide_auth)) -> MeResponse:
         """

{hexcore-11.2.0 → hexcore-11.4.0}/hexcore/darwin/infrastructure/orms/beanie/repositories.py

@@ -245,6 +245,18 @@ class BeanieSessionRepository(_BaseBeanieRepository, AbstractSessionRepository):
             {"$set": {"revoked_at": at, "updated_at": datetime.now(UTC)}}
         )
 
+    async def list_family_session_ids(
+        self, family_id: UUID, *, limit: int = 100
+    ) -> list[UUID]:
+        """Los `id` de la familia, las más recientes primero. Ver el puerto."""
+        docs = (
+            await self._doc.find(self._doc.family_id == family_id)
+            .sort("-created_at")
+            .limit(limit)
+            .to_list()
+        )
+        return [doc.entity_id for doc in docs]
+
     async def revoke_family(
         self, family_id: UUID, *, at: datetime, reason: str
     ) -> int:

{hexcore-11.2.0 → hexcore-11.4.0}/hexcore/darwin/infrastructure/orms/sqlalchemy/repositories.py

@@ -221,6 +221,19 @@ class SqlAlchemySessionRepository(_BaseIdentityRepository, AbstractSessionReposi
             )
             await session.commit()
 
+    async def list_family_session_ids(
+        self, family_id: UUID, *, limit: int = 100
+    ) -> list[UUID]:
+        """Los `id` de la familia, las más recientes primero. Ver el puerto."""
+        async with self._session_scope() as session:
+            resultado = await session.execute(
+                select(self._model.id)
+                .where(self._model.family_id == family_id)
+                .order_by(self._model.created_at.desc())
+                .limit(limit)
+            )
+            return list(resultado.scalars().all())
+
     async def revoke_family(
         self, family_id: UUID, *, at: datetime, reason: str
     ) -> int:

{hexcore-11.2.0 → hexcore-11.4.0}/hexcore/darwin/testing/fakes.py

@@ -259,6 +259,15 @@ class FakeSessionRepository(AbstractSessionRepository):
                 )
                 self.reasons[session_id] = reason
 
+    async def list_family_session_ids(
+        self, family_id: UUID, *, limit: int = 100
+    ) -> list[UUID]:
+        """Los `id` de la familia, las más recientes primero. Ver el puerto."""
+        with self._lock:
+            familia = [s for s in self._por_id.values() if s.family_id == family_id]
+        familia.sort(key=lambda s: s.created_at, reverse=True)
+        return [s.id for s in familia[:limit]]
+
     async def revoke_family(
         self, family_id: UUID, *, at: datetime, reason: str
     ) -> int:

{hexcore-11.2.0 → hexcore-11.4.0}/hexcore/fastapi.py

@@ -37,6 +37,10 @@ _EXPORTS: dict[str, tuple[str, str]] = {
         "RequestIDMiddleware",
     ),
     "TimingMiddleware": ("hexcore.infrastructure.api.middlewares", "TimingMiddleware"),
+    "PredicateCORSMiddleware": (
+        "hexcore.infrastructure.api.middlewares",
+        "PredicateCORSMiddleware",
+    ),
     "RequestIDLogFilter": (
         "hexcore.infrastructure.api.middlewares",
         "RequestIDLogFilter",

{hexcore-11.2.0 → hexcore-11.4.0}/hexcore/fastapi.pyi

@@ -9,7 +9,7 @@
 #
 # Existe porque la fachada resuelve sus exports con `__getattr__` y declara
 # `__all__ = sorted(_EXPORTS)`: las dos son expresiones de runtime, así que sin este stub
-# los 48 símbolos de `hexcore.fastapi` tipan `Any`. El runtime no cambia — Python usa
+# los 49 símbolos de `hexcore.fastapi` tipan `Any`. El runtime no cambia — Python usa
 # el `.py` y el checker usa el `.pyi`, así que la carga perezosa se mantiene.
 
 
@@ -42,6 +42,7 @@ from hexcore.infrastructure.api.lifespan import ProcrastinateStep as Procrastina
 from hexcore.infrastructure.api.lifespan import SqlEngineStep as SqlEngineStep
 from hexcore.infrastructure.api.lifespan import StartupStep as StartupStep
 from hexcore.infrastructure.api.lifespan import build_lifespan as build_lifespan
+from hexcore.infrastructure.api.middlewares import PredicateCORSMiddleware as PredicateCORSMiddleware
 from hexcore.infrastructure.api.middlewares import RequestIDLogFilter as RequestIDLogFilter
 from hexcore.infrastructure.api.middlewares import RequestIDMiddleware as RequestIDMiddleware
 from hexcore.infrastructure.api.middlewares import TimingMiddleware as TimingMiddleware
@@ -74,6 +75,7 @@ __all__ = [
     "EventBusStep",
     "HealthReport",
     "HealthRoutes",
+    "PredicateCORSMiddleware",
     "Probe",
     "ProcrastinateStep",
     "RequestIDLogFilter",

{hexcore-11.2.0 → hexcore-11.4.0}/hexcore/infrastructure/api/app.py

@@ -16,7 +16,7 @@ from pydantic import BaseModel
 
 from .exception_handlers import HeadersFactory, PayloadFactory, register_exception_handlers
 from .health import Probe, ResponseFactory, register_health_routes
-from .middlewares import RequestIDMiddleware, TimingMiddleware
+from .middlewares import PredicateCORSMiddleware, RequestIDMiddleware, TimingMiddleware
 from .routing import MountableRouter, mount_routers
 
 __all__ = ["AppFeatures", "HealthRoutes", "create_app"]
@@ -139,14 +139,6 @@ def create_app(
     # Los middlewares de Starlette se ejecutan en orden inverso al de registro, así que
     # el request-id se añade último para que envuelva a todo lo demás y su ContextVar
     # esté disponible en el resto de la pila.
-    if resolved_features.cors:
-        app.add_middleware(
-            CORSMiddleware,
-            allow_origins=list(getattr(config, "allow_origins", ["*"])),
-            allow_credentials=bool(getattr(config, "allow_credentials", True)),
-            allow_methods=list(getattr(config, "allow_methods", ["*"])),
-            allow_headers=list(getattr(config, "allow_headers", ["*"])),
-        )
     if resolved_features.timing:
         app.add_middleware(TimingMiddleware)
 
@@ -164,6 +156,39 @@ def create_app(
 
         app.add_middleware(AuthContextMiddleware)
 
+    # El CORS va **después** de los de Darwin —o sea, por fuera de ellos— y antes del
+    # request-id. Un middleware sólo le agrega cabeceras a lo que responde por dentro de él:
+    # con el CORS más adentro que el CSRF, el 403 de un `POST` cross-origin sin token salía
+    # sin `Access-Control-Allow-Origin`, y el navegador lo convertía en un error de red opaco
+    # en vez de dejarle leer a la app *por qué* falló (y reintentar con un token nuevo). Y
+    # el preflight se contesta acá, antes de gastar la resolución de la credencial.
+    if resolved_features.cors:
+        expose_headers = list(getattr(config, "cors_expose_headers", []))
+        if resolved_features.csrf:
+            # Darwin entrega el token anti-CSRF también en esta cabecera (para la SPA en otro
+            # origen, que no puede leer la cookie): sin exponerla, el JS no la ve.
+            from hexcore.darwin.infrastructure.api.middlewares import CSRF_HEADER
+
+            if CSRF_HEADER.lower() not in (h.lower() for h in expose_headers):
+                expose_headers.append(CSRF_HEADER)
+        cors_kwargs: dict[str, t.Any] = {
+            "allow_origins": list(getattr(config, "allow_origins", ["*"])),
+            "allow_credentials": bool(getattr(config, "allow_credentials", True)),
+            "allow_methods": list(getattr(config, "allow_methods", ["*"])),
+            "allow_headers": list(getattr(config, "allow_headers", ["*"])),
+            "expose_headers": expose_headers,
+            "max_age": int(getattr(config, "cors_max_age", 600)),
+        }
+        origin_predicate = getattr(config, "cors_origin_predicate", None)
+        if origin_predicate is None:
+            # Sin predicado, la clase es la de Starlette tal cual: nada cambia para quien no
+            # lo pide.
+            app.add_middleware(CORSMiddleware, **cors_kwargs)
+        else:
+            app.add_middleware(
+                PredicateCORSMiddleware, origin_predicate=origin_predicate, **cors_kwargs
+            )
+
     if resolved_features.request_id:
         app.add_middleware(RequestIDMiddleware)
 

{hexcore-11.2.0 → hexcore-11.4.0}/hexcore/infrastructure/api/middlewares.py

@@ -15,12 +15,16 @@ import uuid
 import warnings
 from contextvars import ContextVar
 
+from starlette.datastructures import Headers, MutableHeaders
 from starlette.middleware.base import BaseHTTPMiddleware, RequestResponseEndpoint
+from starlette.middleware.cors import CORSMiddleware
 from starlette.requests import Request
 from starlette.responses import Response
+from starlette.types import Message, Receive, Scope, Send
 
 __all__ = [
     "REQUEST_ID",
+    "PredicateCORSMiddleware",
     "RequestIDMiddleware",
     "TimingMiddleware",
     "RequestIDLogFilter",
@@ -102,6 +106,66 @@ class TimingMiddleware(BaseHTTPMiddleware):
         return response
 
 
+cors_logger = logging.getLogger("hexcore.api.cors")
+
+
+class PredicateCORSMiddleware(CORSMiddleware):
+    """
+    `CORSMiddleware` que además acepta los orígenes que un predicado apruebe.
+
+    `allow_origins` es una lista fija, y un subdominio por tenant creado en caliente no se puede
+    enumerar de antemano: sin esto hay que redesplegar por cada alta, o abrir `"*"` — que con
+    credenciales no es válido. El predicado se consulta **sólo** cuando el origen no está ya en
+    la lista, así que declarar los dos no duplica trabajo.
+
+    Dos decisiones que no son obvias:
+
+    * **Falla cerrado.** Un predicado que lanza se trata como «no confiable» y se loguea en
+      `hexcore.api.cors`: un chequeo de confianza que explota nunca decide «confío» por default.
+      El log importa porque el síntoma —un origen legítimo sin CORS— no apunta a ninguna causa.
+    * **`Vary: Origin` siempre.** Con orígenes dinámicos la respuesta depende del `Origin`
+      también cuando se rechaza; sin `Vary`, una caché compartida podría servirle a un origen
+      aceptado la respuesta que guardó sin `Access-Control-Allow-Origin`. Starlette sólo lo
+      agrega cuando el origen es aceptado.
+    """
+
+    def __init__(
+        self,
+        app: t.Any,
+        *,
+        origin_predicate: t.Callable[[str], bool],
+        **kwargs: t.Any,
+    ) -> None:
+        super().__init__(app, **kwargs)
+        self._origin_predicate = origin_predicate
+
+    def is_allowed_origin(self, origin: str) -> bool:
+        if super().is_allowed_origin(origin):
+            return True
+        try:
+            return bool(self._origin_predicate(origin))
+        except Exception:
+            cors_logger.exception(
+                "cors_origin_predicate lanzó evaluando el origen %r; se lo trata como no "
+                "confiable.",
+                origin,
+            )
+            return False
+
+    async def simple_response(
+        self, scope: Scope, receive: Receive, send: Send, request_headers: Headers
+    ) -> None:
+        async def con_vary(message: Message) -> None:
+            if message["type"] == "http.response.start":
+                message.setdefault("headers", [])
+                headers = MutableHeaders(scope=message)
+                if "origin" not in headers.get("vary", "").lower():
+                    headers.add_vary_header("Origin")
+            await send(message)
+
+        await super().simple_response(scope, receive, con_vary, request_headers)
+
+
 class RequestIDLogFilter(logging.Filter):
     """
     Inyecta el request-id en cada `LogRecord` como ``record.request_id``.

{hexcore-11.2.0 → hexcore-11.4.0/hexcore.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hexcore
-Version: 11.2.0
+Version: 11.4.0
 Summary: Reusable core for Python projects with hexagonal architecture, DDD, CQRS and background tasks. Ships the abstractions and the infrastructure: SQL session layer, FastAPI factories, worker runner, dynamic cron and identity.
 Author-email: "David Latosefki (Indroic)" <indroic@outlook.com>
 License-Expression: MIT

{hexcore-11.2.0 → hexcore-11.4.0}/hexcore.egg-info/SOURCES.txt

@@ -290,6 +290,7 @@ hexcore/testing/repositories.py
 tests/test_alembic_metadata_completeness.py
 tests/test_anclas_del_repo.py
 tests/test_api_app_and_lifespan.py
+tests/test_api_cors_dinamico.py
 tests/test_api_cqrs_providers.py
 tests/test_api_exception_handlers.py
 tests/test_api_health.py