feat: add memory stores

Author: Harshal6927

AGENTS.md

@@ -0,0 +1,101 @@
+# Agent Guidelines for litestar-start
+
+This document contains instructions for AI agents operating in this repository.
+
+## 1. Build, Lint, and Test Commands
+
+This project uses `uv` for dependency management and `hatchling` for building.
+
+### Dependency Management
+- **Install dependencies:** `uv sync`
+- **Update lockfile:** `uv lock` (or `uv lock --upgrade` to upgrade)
+
+### Testing
+- **Run all tests:**
+  ```bash
+  pytest
+  ```
+- **Run a single test file:**
+  ```bash
+  pytest tests/test_generator.py
+  ```
+- **Run a specific test case:**
+  ```bash
+  pytest tests/test_generator.py::test_function_name
+  ```
+- **Run with verbose output:**
+  ```bash
+  pytest -v
+  ```
+
+### Linting and Formatting
+- **Run all linters (Ruff, Type Checking, Pre-commit):**
+  ```bash
+  make lint
+  ```
+  *Note: This runs `ruff check --fix`, `ty check`, and `pre-commit run -a`.*
+
+- **Run Ruff manually:**
+  ```bash
+  ruff check .
+  ```
+
+- **Run Type Checking manually:**
+  ```bash
+  ty check
+  ```
+
+## 2. Code Style Guidelines
+
+Adhere strictly to the following conventions to match the existing codebase.
+
+### General
+- **Python Version:** Target Python 3.13+.
+- **Line Length:** 120 characters (configured in `pyproject.toml`).
+- **File Operations:** Always use `pathlib.Path` instead of `os.path` strings.
+- **Data Models:** Use `msgspec.Struct` for defining data structures/configurations, not `dataclasses` or `pydantic`.
+- **Enums:** Use `enum.StrEnum` for string-based enumerations.
+
+### Imports
+- Group imports:
+  1. Standard library (e.g., `pathlib`, `re`)
+  2. Third-party libraries (e.g., `jinja2`, `msgspec`)
+  3. Local application imports (e.g., `src.utils`)
+- Imports are sorted automatically by Ruff; attempt to group them logically.
+
+### Typing
+- **Strict Typing:** All functions and methods must have type annotations for arguments and return values.
+- Use built-in types (`list`, `dict`, `set`) instead of `typing.List`, etc.
+- Use `|` for unions (e.g., `str | None`) instead of `Optional` or `Union`.
+
+### Naming Conventions
+- **Variables/Functions:** `snake_case`
+- **Classes:** `PascalCase`
+- **Constants:** `SCREAMING_SNAKE_CASE`
+- **Private Members:** Prefix with `_` (though `SLF001` is ignored in Ruff, still prefer public interfaces).
+
+### Docstrings
+- Use **Google-style** docstrings for all public modules, functions, classes, and methods.
+- Format:
+  ```python
+  def function(arg: int) -> str:
+      """Short summary of the function.
+
+      Args:
+          arg: Description of the argument.
+
+      Returns:
+          Description of the return value.
+
+      """
+  ```
+
+### Error Handling
+- Validate inputs early (fail fast).
+- Use specific exceptions where possible.
+- Avoid bare `except:` blocks.
+
+### Directory Structure
+- `src/`: Source code.
+- `tests/`: Test files (mirrors source structure or flat list).
+- `tools/`: Build and maintenance scripts.

src/Litestar/App/app.py.jinja

@@ -14,6 +14,9 @@ from .controllers import UserController
 {% if litestar_vite %}
 from litestar_vite import ViteConfig, VitePlugin
 {% endif %}
+{% if has_store %}
+from .config import redis_store
+{% endif %}
 
 @get("/health")
 async def health() -> dict[str, str]:
@@ -40,6 +43,9 @@ app = Litestar(
         },
         log_exceptions="always",
     ),
+{% if has_store %}
+    stores={"redis": redis_store},
+{% endif %}
 {% if advanced_alchemy %}
     exception_handlers={
         Exception: exception_handler,

src/Litestar/App/config.py.jinja

@@ -9,6 +9,9 @@ from advanced_alchemy.extensions.litestar import (
 from pathlib import Path
 from litestar_vite import ViteConfig, PathConfig
 {% endif %}
+{% if has_store %}
+from litestar.stores.redis import RedisStore
+{% endif %}
 
 from .settings import get_settings
 
@@ -37,3 +40,11 @@ vite_config = ViteConfig(
     ),
 )
 {% endif %}
+
+{% if has_store %}
+redis_store = RedisStore.with_client(
+    url=settings.REDIS_URL,
+    port=6379,
+    db=0,
+)
+{% endif %}

src/Litestar/App/settings.py.jinja

@@ -47,6 +47,13 @@ class Settings:
 {% endif %}
 {% endif %}
 
+{% if has_store %}
+    # Memory Store
+    REDIS_URL: str = field(
+        default_factory=lambda: os.getenv("REDIS_URL", "{{ store_config.default_url }}")
+    )
+{% endif %}
+
     @classmethod
     def from_env(cls, dotenv_filename: str) -> "Settings":
         env_file = (

src/Litestar/Config/.env.example.jinja

@@ -18,3 +18,8 @@ DATABASE_URL=sqlite+aiosqlite:///./app.db
 DATABASE_URL=mysql+asyncmy://myuser:mypassword@localhost:3306/mydb
 {% endif %}
 {% endif %}
+
+{% if has_store %}
+# Memory Store
+REDIS_URL={{ store_config.default_url }}
+{% endif %}

src/Litestar/Config/pyproject.toml.jinja

@@ -20,6 +20,9 @@ dependencies = [
 {% if litestar_vite %}
     "litestar-vite>=0.18.1",
 {% endif %}
+{% if has_store %}
+    "redis>=5.2.1",
+{% endif %}
 ]
 
 [tool.ruff]

src/Litestar/Containers/docker-compose.infra.yml.jinja

@@ -43,3 +43,28 @@ volumes:
 volumes:
   {{ project_slug }}_mysql_dev_db: {}
   {% endif %}
+  {% if memory_store.value == "Redis" %}
+  redis:
+    image: {{ store_config.docker_image }}
+    container_name: {{ project_slug }}_redis_dev
+    ports:
+      - "{{ store_config.port }}:6379"
+    healthcheck:
+      test: ["CMD", "redis-cli", "ping"]
+      interval: 10s
+      timeout: 5s
+      retries: 5
+    restart: unless-stopped
+  {% elif memory_store.value == "Valkey" %}
+  valkey:
+    image: {{ store_config.docker_image }}
+    container_name: {{ project_slug }}_valkey_dev
+    ports:
+      - "{{ store_config.port }}:6379"
+    healthcheck:
+      test: ["CMD", "valkey-cli", "ping"]
+      interval: 10s
+      timeout: 5s
+      retries: 5
+    restart: unless-stopped
+  {% endif %}

src/Litestar/Containers/docker-compose.yml.jinja

@@ -18,16 +18,27 @@ services:
       - DATABASE_URL=sqlite+aiosqlite:///./app.db
       {% endif %}
     {% endif %}
+    {% if has_store %}
+      - REDIS_URL=redis://{{ project_slug }}_{{ memory_store.value|lower }}:6379/0
+    {% endif %}
     env_file:
       - .env
-    {% if database.value == "PostgreSQL" %}
+    {% if (database.value == "PostgreSQL" or database.value == "MySQL") or has_store %}
     depends_on:
+      {% if database.value == "PostgreSQL" %}
       postgres:
         condition: service_healthy
-    {% elif database.value == "MySQL" %}
-    depends_on:
+      {% elif database.value == "MySQL" %}
       mysql:
         condition: service_healthy
+      {% endif %}
+      {% if memory_store.value == "Redis" %}
+      redis:
+        condition: service_healthy
+      {% elif memory_store.value == "Valkey" %}
+      valkey:
+        condition: service_healthy
+      {% endif %}
     {% endif %}
     restart: unless-stopped
 
@@ -70,6 +81,32 @@ services:
     restart: unless-stopped
   {% endif %}
 
+  {% if memory_store.value == "Redis" %}
+  redis:
+    image: {{ store_config.docker_image }}
+    container_name: {{ project_slug }}_redis
+    ports:
+      - "{{ store_config.port }}:6379"
+    healthcheck:
+      test: ["CMD", "redis-cli", "ping"]
+      interval: 10s
+      timeout: 5s
+      retries: 5
+    restart: unless-stopped
+  {% elif memory_store.value == "Valkey" %}
+  valkey:
+    image: {{ store_config.docker_image }}
+    container_name: {{ project_slug }}_valkey
+    ports:
+      - "{{ store_config.port }}:6379"
+    healthcheck:
+      test: ["CMD", "valkey-cli", "ping"]
+      interval: 10s
+      timeout: 5s
+      retries: 5
+    restart: unless-stopped
+  {% endif %}
+
 {% if database.value == "PostgreSQL" %}
 volumes:
   {{ project_slug }}_postgres_db: {}

src/Litestar/generator.py

@@ -4,7 +4,7 @@
 
 from jinja2 import Environment
 
-from src.models import DatabaseConfig, ProjectConfig
+from src.models import DatabaseConfig, MemoryStoreConfig, ProjectConfig
 from src.plugin import discover_plugins
 from src.utils import get_package_dir, get_template_env, write_file
 
@@ -33,6 +33,7 @@ def _get_template_context(self) -> dict:
 
         """
         db_config = DatabaseConfig.for_database(self.config.database)
+        store_config = MemoryStoreConfig.for_store(self.config.memory_store)
 
         context = {
             "project": self.config,
@@ -41,6 +42,9 @@ def _get_template_context(self) -> dict:
             "database": self.config.database,
             "db_config": db_config,
             "has_database": self.config.database.value != "None",
+            "memory_store": self.config.memory_store,
+            "store_config": store_config,
+            "has_store": self.config.memory_store.value != "None",
             "docker": self.config.docker,
             "docker_infra": self.config.docker_infra,
         }

src/cli.py

@@ -10,7 +10,7 @@
 from rich.text import Text
 
 from src.generator import ProjectGenerator
-from src.models import Database, Framework, ProjectConfig
+from src.models import Database, Framework, MemoryStore, ProjectConfig
 from src.plugin import Plugin, discover_plugins
 from src.utils import validate_project_name
 
@@ -107,6 +107,34 @@ def ask_database() -> Database:
     return result
 
 
+def ask_memory_store() -> MemoryStore:
+    """Ask for the memory store choice.
+
+    Returns:
+        The selected memory store.
+
+    Raises:
+        SystemExit: If the user cancels the operation.
+
+    """
+    choices = [
+        questionary.Choice(title="Redis", value=MemoryStore.REDIS),
+        questionary.Choice(title="Valkey", value=MemoryStore.VALKEY),
+        questionary.Choice(title="None", value=MemoryStore.NONE),
+    ]
+
+    result = questionary.select(
+        "Select memory store:",
+        choices=choices,
+    ).ask()
+
+    if result is None:
+        console.print("\n[yellow]Cancelled.[/yellow]")
+        raise SystemExit(0)
+
+    return result
+
+
 def ask_plugins(config: ProjectConfig, discovered_plugins: list[Plugin]) -> list[str]:
     """Ask for plugins to install.
 
@@ -251,6 +279,7 @@ def main() -> None:
         name = ask_project_name()
         framework = ask_framework()
         database = ask_database()
+        memory_store = ask_memory_store()
 
         # Discover plugins early to pass to ask_plugins
         discovered_plugins = discover_plugins(framework.value)
@@ -260,6 +289,7 @@ def main() -> None:
             name=name,
             framework=framework,
             database=database,
+            memory_store=memory_store,
             plugins=[],  # Will be populated next
             docker=False,  # Placeholder
             docker_infra=False,  # Placeholder
@@ -279,6 +309,7 @@ def main() -> None:
                 f"[bold]Project:[/bold] {config.name}\n"
                 f"[bold]Framework:[/bold] {config.framework.value}\n"
                 f"[bold]Database:[/bold] {config.database.value}\n"
+                f"[bold]Memory Store:[/bold] {config.memory_store.value}\n"
                 f"[bold]Plugins:[/bold] {', '.join(config.plugins) or 'None'}\n"
                 f"[bold]Docker:[/bold] {'Yes' if config.docker else 'No'}\n"
                 f"[bold]Docker Infra:[/bold] {'Yes' if config.docker_infra else 'No'}",