Merge branch 'main' into test/vrt-perf-and-gallery

Author: shayancoin

.gitignore

@@ -42,6 +42,8 @@ artifacts/
 .env
 .env.*
 !.env.example
+secrets/*.env
+!secrets/*.env.example
 
 # Docker
 **/.dockerignore

backend/api/deps.py

@@ -0,0 +1,113 @@
+"""Shared lightweight dependency helpers."""
+
+from __future__ import annotations
+
+import time
+from typing import Optional, Protocol
+
+from fastapi import Depends
+
+from api.config import Settings, get_settings
+
+try:
+    from redis import asyncio as redis_asyncio
+except Exception:  # pragma: no cover - optional dependency
+    redis_asyncio = None  # type: ignore[assignment]
+
+
+class RedisLike(Protocol):
+    async def get(self, key: str) -> Optional[str]:
+        """
+        Retrieve a value by key from the in-memory store, respecting expiry.
+        
+        Returns:
+            The stored string value for `key`, or `None` if the key is missing or has expired.
+        """
+        ...
+
+    async def set(self, key: str, value: str, ex: Optional[int] = None) -> None:
+        """
+        Store a string value under the given key, optionally expiring after a number of seconds.
+        
+        Parameters:
+            key (str): Key under which to store the value.
+            value (str): String value to store.
+            ex (Optional[int]): Expiration time in seconds; if provided, the key will be removed after this many seconds. Existing values for the key are overwritten.
+        """
+        ...
+
+
+class _InMemoryRedis:
+    """Minimal in-memory Redis replacement used when redis-py asyncio is unavailable."""
+
+    def __init__(self) -> None:
+        """
+        Initialize internal storage for the in-memory Redis replacement.
+        
+        Creates the `_store` dictionary that maps keys (str) to tuples of `(value, expires_at)`,
+        where `value` is the stored string and `expires_at` is a Unix timestamp (float) when the
+        entry expires or `None` if it does not expire.
+        """
+        self._store: dict[str, tuple[str, Optional[float]]] = {}
+
+    async def get(self, key: str) -> Optional[str]:
+        """
+        Retrieve the string value stored for the given key if it exists and has not expired.
+        
+        If the key is missing or its expiry time has passed, the key is removed from the in-memory store and `None` is returned.
+        
+        Returns:
+            The stored `str` value for `key`, or `None` if the key does not exist or is expired.
+        """
+        payload = self._store.get(key)
+        if payload is None:
+            return None
+        value, expires_at = payload
+        if expires_at is not None and expires_at < time.monotonic():
+            self._store.pop(key, None)
+            return None
+        return value
+
+    async def set(self, key: str, value: str, ex: Optional[int] = None) -> None:
+        """
+        Store a string value under a key with an optional TTL in seconds.
+        
+        Parameters:
+            key (str): The key to store the value under.
+            value (str): The string value to store.
+            ex (Optional[int]): Time-to-live in seconds; if provided, the key expires after this many seconds.
+        """
+        expires_at = time.monotonic() + ex if ex is not None else None
+        self._store[key] = (value, expires_at)
+
+
+_redis_client: Optional["redis_asyncio.Redis"] = None  # type: ignore[misc]
+_fallback_client = _InMemoryRedis()
+
+
+async def get_redis(settings: Settings = Depends(get_settings)) -> RedisLike:
+    """
+    Provide a shared Redis-like client: use the asyncio Redis client when available, otherwise use the in-memory fallback.
+    
+    Parameters:
+        settings (Settings): Application settings used to obtain `redis_url` when lazily initializing the asyncio Redis client.
+    
+    Returns:
+        RedisLike: The module-level Redis-like client (an initialized asyncio Redis client if available, otherwise the in-memory fallback).
+    """
+
+    global _redis_client
+
+    if redis_asyncio is None:
+        return _fallback_client
+
+    if _redis_client is None:
+        _redis_client = redis_asyncio.from_url(
+            settings.redis_url,
+            encoding="utf-8",
+            decode_responses=True,
+        )
+    return _redis_client
+
+
+__all__ = ["get_redis", "RedisLike"]

backend/api/graphql.py

@@ -0,0 +1,93 @@
+"""Strawberry GraphQL façade exposing pricing queries."""
+
+from __future__ import annotations
+
+import strawberry
+from strawberry.fastapi import GraphQLRouter
+
+from api.config import get_settings
+from api.deps import get_redis
+from backend.api.routes_pricing import PriceRequest, PriceResponse, compute_price_quote
+
+
+@strawberry.type
+class PriceBreakdown:
+    base: int
+    finish: int
+    hardware: int
+    countertop: int
+
+
+@strawberry.type
+class PriceQuote:
+    total_cents: int
+    breakdown: PriceBreakdown
+
+
+def _to_graphql(response: PriceResponse) -> PriceQuote:
+    """
+    Convert a backend PriceResponse into a GraphQL PriceQuote.
+    
+    Constructs a PriceQuote with total_cents from the response and a nested PriceBreakdown populated from the response.breakdown keys: "base", "finish", "hardware", and "countertop".
+    
+    Returns:
+        PriceQuote: GraphQL PriceQuote with mapped `total_cents` and `breakdown`.
+    """
+    breakdown = response.breakdown
+    return PriceQuote(
+        total_cents=response.total_cents,
+        breakdown=PriceBreakdown(
+            base=breakdown["base"],
+            finish=breakdown["finish"],
+            hardware=breakdown["hardware"],
+            countertop=breakdown["countertop"],
+        ),
+    )
+
+
+@strawberry.type
+class Query:
+    @strawberry.field
+    async def price_quote(
+        self,
+        elevation: str,
+        finish: str,
+        hardware: str,
+        countertop: str,
+    ) -> PriceQuote:
+        """
+        Resolve a price quote for a product configuration specified by the provided attributes.
+        
+        Builds a price request from the provided elevation, finish, hardware, and countertop identifiers, queries the pricing backend, and returns the result as a GraphQL PriceQuote.
+        
+        Parameters:
+            elevation (str): Identifier for the product elevation/profile.
+            finish (str): Identifier for the surface finish option.
+            hardware (str): Identifier for the hardware option.
+            countertop (str): Identifier for the countertop option.
+        
+        Returns:
+            PriceQuote: GraphQL representation of the computed price, including `total_cents` and a `breakdown` of cost components.
+        """
+        request = PriceRequest(
+            elevation=elevation,
+            finish=finish,
+            hardware=hardware,
+            countertop=countertop,
+        )
+        redis = await get_redis(settings=get_settings())
+        response = await compute_price_quote(request, redis)
+        return _to_graphql(response)
+
+
+schema = strawberry.Schema(query=Query)
+
+_settings = get_settings()
+graphql_app = GraphQLRouter(
+    schema,
+    graphiql=_settings.environment != "production",
+    allow_introspection=_settings.environment != "production",
+)
+
+
+__all__ = ["graphql_app", "schema"]