feat: support for structured scaffold in create command

integration_tests/test_cli.py

@@ -4,11 +4,27 @@
 
 
 # Unit tests
-def test_create_robyn_app():
+def test_create_robyn_app_simple():
     with patch("robyn.cli.prompt") as mock_prompt:
         mock_prompt.return_value = {
             "directory": "test_dir",
             "docker": "N",
+            "scaffold_type": "simple",
+            "project_type": "no-db",
+        }
+        with patch("robyn.cli.os.makedirs") as mock_makedirs:
+            with patch("robyn.cli.shutil.copytree") as mock_copytree, patch("robyn.os.remove") as _mock_remove:
+                create_robyn_app()
+                mock_makedirs.assert_called_once()
+                mock_copytree.assert_called_once()
+
+
+def test_create_robyn_app_structured():
+    with patch("robyn.cli.prompt") as mock_prompt:
+        mock_prompt.return_value = {
+            "directory": "test_dir",
+            "docker": "N",
+            "scaffold_type": "structured",
             "project_type": "no-db",
         }
         with patch("robyn.cli.os.makedirs") as mock_makedirs:

robyn/cli.py

@@ -36,24 +36,53 @@ def create_robyn_app():
         },
         {
             "type": "list",
-            "message": "Please select project type (Mongo/Postgres/Sqlalchemy/Prisma): ",
-            "choices": [
-                Choice("no-db", name="No DB"),
-                Choice("sqlite", name="Sqlite"),
-                Choice("postgres", name="Postgres"),
-                Choice("mongo", name="MongoDB"),
-                Choice("sqlalchemy", name="SqlAlchemy"),
-                Choice("prisma", name="Prisma"),
-                Choice("sqlmodel", name="SQLModel"),
-            ],
-            "default": Choice("no-db", name="No DB"),
-            "name": "project_type",
+            "name": "scaffold_type",
+            "choices": [Choice("simple", name="Simple"), Choice("structured", name="Structured")],
+            "message": "Please choose if you'd like the scaffold to be a simple starter kit or an opinionated structure",
         },
     ]
     result = prompt(questions=questions)
     project_dir_path = Path(str(result["directory"])).resolve()
     docker = result["docker"]
-    project_type = str(result["project_type"])
+    scaffold_type: str = str(result["scaffold_type"])
+    if scaffold_type == "simple":
+        scaffold_type: str = "simple"
+        result = prompt(
+            questions=[
+                {
+                    "type": "list",
+                    "message": "Please select project type (Mongo/Postgres/Sqlalchemy/Prisma): ",
+                    "choices": [
+                        Choice("no-db", name="No DB"),
+                        Choice("sqlite", name="Sqlite"),
+                        Choice("postgres", name="Postgres"),
+                        Choice("mongo", name="MongoDB"),
+                        Choice("sqlalchemy", name="SqlAlchemy"),
+                        Choice("prisma", name="Prisma"),
+                        Choice("sqlmodel", name="SQLModel"),
+                    ],
+                    "default": Choice("no-db", name="No DB"),
+                    "name": "project_type",
+                }
+            ]
+        )
+        project_type = str(result["project_type"])
+    else:
+        result = prompt(
+            questions=[
+                {
+                    "type": "list",
+                    "message": "Please select project type (Mongo/Postgres/Sqlalchemy/Prisma): ",
+                    "choices": [
+                        Choice("no-db", name="No DB"),
+                        Choice("sqlalchemy", name="SqlAlchemy"),
+                    ],
+                    "default": Choice("no-db", name="No DB"),
+                    "name": "project_type",
+                }
+            ]
+        )
+        project_type = str(result["project_type"])
 
     final_project_dir_path = (CURRENT_WORKING_DIR / project_dir_path).resolve()
 
@@ -62,12 +91,15 @@ def create_robyn_app():
     # Create a new directory for the project
     os.makedirs(final_project_dir_path, exist_ok=True)
 
-    selected_project_template = (SCAFFOLD_DIR / Path(project_type)).resolve()
+    selected_project_template = (SCAFFOLD_DIR / Path(scaffold_type) / Path(project_type)).resolve()
     shutil.copytree(str(selected_project_template), str(final_project_dir_path), dirs_exist_ok=True)
 
     # If docker is not needed, delete the docker file
     if docker == "N":
-        os.remove(f"{final_project_dir_path}/Dockerfile")
+        if scaffold_type == "simple":
+            os.remove(f"{final_project_dir_path}/Dockerfile")
+        else:
+            shutil.rmtree(f"{final_project_dir_path}/devops", ignore_errors=True)
 
     print(f"New Robyn project created in '{final_project_dir_path}' ")
 

robyn/helpers.py

@@ -0,0 +1,47 @@
+from typing import Any, Type, Tuple
+from pydantic_settings import (
+    BaseSettings,
+    EnvSettingsSource,
+    PydanticBaseSettingsSource,
+)
+from pydantic import ConfigDict
+
+import importlib
+import pkgutil
+import logging
+
+from robyn import Robyn
+
+logger = logging.getLogger(__name__)
+
+
+def discover_routes(handler_path: str = "api.handlers") -> Robyn:
+    mux: Robyn = Robyn(__file__)
+    package = importlib.import_module(handler_path)
+    for _, module_name, _ in pkgutil.iter_modules(package.__path__, package.__name__ + "."):
+        module = importlib.import_module(module_name)
+        logger.info(f"member: {module}")
+        mux.include_router(module.router)
+    return mux
+
+
+class AcceptArrayEnvsSource(EnvSettingsSource):
+    def prepare_field_value(self, field_name: str, field: Any, value: Any, value_is_complex: bool) -> Any:
+        if isinstance(field.annotation, type) and issubclass(field.annotation, list) and isinstance(value, str):
+            return [x.strip() for x in value.split(",") if x]
+        return value
+
+
+class BaseConfig(BaseSettings):
+    @classmethod
+    def settings_customise_sources(
+        cls,
+        settings_cls: Type[BaseSettings],
+        init_settings: PydanticBaseSettingsSource,
+        env_settings: PydanticBaseSettingsSource,
+        dotenv_settings: PydanticBaseSettingsSource,
+        file_secret_settings: PydanticBaseSettingsSource,
+    ) -> Tuple[PydanticBaseSettingsSource, ...]:
+        return (AcceptArrayEnvsSource(settings_cls),)
+
+    model_config = ConfigDict(extra="ignore")  # Ignore extra environment variables

robyn/scaffold/structured/no-db/api/handlers/probes.py

@@ -0,0 +1,14 @@
+from robyn import SubRouter
+
+
+router = SubRouter(__name__, prefix="/")
+
+
+@router.get("/livez/")
+def livez() -> str:
+    return "live"
+
+
+@router.get("/healthz/")
+def healthz() -> str:
+    return "healthy"

robyn/scaffold/structured/no-db/api/handlers/sample.py

@@ -0,0 +1,13 @@
+from robyn import SubRouter
+
+router = SubRouter(__name__, "/sample")
+
+
+class SampleHandlers:
+    @router.post("/one")
+    @staticmethod
+    def one(): ...
+
+    @router.get("/two")
+    @staticmethod
+    def two(): ...

robyn/scaffold/structured/no-db/conf.py

@@ -0,0 +1,8 @@
+from robyn.helpers import BaseConfig
+
+
+class Settings(BaseConfig):
+    service_port: int
+
+
+settings = Settings()

robyn/scaffold/structured/no-db/config.env

@@ -0,0 +1 @@
+SERVICE_PORT=3000

robyn/scaffold/structured/no-db/devops/Dockerfile

@@ -0,0 +1,14 @@
+FROM python:3.11-bookworm AS builder
+
+WORKDIR /workspace
+
+COPY . .
+RUN pip install --no-cache-dir --upgrade -r requirements.txt --target=/workspace/deps
+
+FROM gcr.io/distroless/python3-debian11
+
+WORKDIR /workspace
+COPY --from=builder /workspace /workspace
+ENV PYTHONPATH=/workspace/deps
+
+CMD ["server.py", "--log-level=DEBUG"]

robyn/scaffold/structured/no-db/devops/docker-compose.yaml

@@ -0,0 +1,11 @@
+version: '3'
+services:
+
+  service:
+    image: service # build an image with this tag
+    container_name: "service"
+    env_file:
+    - ../config.env
+    network_mode: host
+
+

robyn/scaffold/structured/no-db/requirements.txt

@@ -0,0 +1,3 @@
+robyn
+pydantic~=2.7.4
+pydantic-settings~=2.2.1

robyn/scaffold/structured/no-db/server.py

@@ -0,0 +1,11 @@
+from robyn.helpers import discover_routes
+from robyn import Robyn
+
+from conf import settings
+
+app: Robyn = discover_routes("api.handlers")
+# note: if you prefer to manuall refine routes, use your build_routes function instead
+
+
+if __name__ == "__main__":
+    app.start(host="0.0.0.0", port=settings.service_port)

robyn/scaffold/structured/sqlalchemy/adaptors/models/__init__.py

@@ -0,0 +1,3 @@
+from .user import Base as user
+
+metadata = [user.metadata]

robyn/scaffold/structured/sqlalchemy/adaptors/models/user.py

@@ -0,0 +1,36 @@
+from sqlalchemy import String, Integer, Boolean
+from sqlalchemy.orm import DeclarativeBase, Mapped, mapped_column
+from pydantic import BaseModel
+
+
+class Base(DeclarativeBase):
+    pass
+
+
+class User(Base):
+    __tablename__ = "users"
+
+    id: Mapped[int] = mapped_column(Integer, primary_key=True, index=True)
+    username: Mapped[str] = mapped_column(String, unique=True, index=True)
+    hashed_password: Mapped[str] = mapped_column(String)
+    is_active: Mapped[bool] = mapped_column(Boolean, default=True)
+    is_superuser: Mapped[bool] = mapped_column(Boolean, default=False)
+
+
+class UserRead(BaseModel):
+    id: int
+    username: str
+    is_active: bool
+    is_superuser: bool
+
+    class Config:
+        orm_mode = True
+
+
+# Pydantic model for creating/updating a user
+class UserCreate(BaseModel):
+    username: str
+    password: str
+
+    class Config:
+        orm_mode = True

robyn/scaffold/structured/sqlalchemy/adaptors/mutators/__init__.py

@@ -0,0 +1,14 @@
+from abc import ABC, abstractmethod
+
+from pydantic import BaseModel
+
+
+class Mutator(ABC):
+    @abstractmethod
+    def create(self, model: BaseModel): ...
+
+    @abstractmethod
+    def update(self, **kwargs): ...
+
+    @abstractmethod
+    def delete(self, **kwargs): ...

robyn/scaffold/structured/sqlalchemy/adaptors/selectors/__init__.py

@@ -0,0 +1,9 @@
+from abc import ABC, abstractmethod
+
+
+class Mutator(ABC):
+    @abstractmethod
+    def retrieve(self, **kwargs): ...
+
+    @abstractmethod
+    def list(self, **kwargs): ...

robyn/scaffold/structured/sqlalchemy/adaptors/selectors/misc.py

@@ -0,0 +1,5 @@
+from sqlalchemy import text
+
+
+async def sample_selector(conn):
+    await conn.execute(text("select * from sample;"))