csrd-utils 0.3.57__tar.gz → 0.3.59__tar.gz

{csrd_utils-0.3.57 → csrd_utils-0.3.59}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: csrd-utils
-Version: 0.3.57
+Version: 0.3.59
 Summary: CLI utilities for csrd service generation and feature augmentation
 Project-URL: Repository, https://github.com/csrd-api/fastapi-common
 Project-URL: Documentation, https://github.com/csrd-api/fastapi-common/tree/main/packages/utils

{csrd_utils-0.3.57 → csrd_utils-0.3.59}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "csrd-utils"
-version = "0.3.57"
+version = "0.3.59"
 description = "CLI utilities for csrd service generation and feature augmentation"
 license = { text = "MIT" }
 requires-python = ">=3.12"

{csrd_utils-0.3.57 → csrd_utils-0.3.59}/src/csrd_utils/cluster.py

@@ -30,6 +30,7 @@ DEFAULT_PORT_START = 8091
 PRESETS: dict[str, list[ServiceSpec]] = {
     "none": [],
     "authenticated-cluster": [
+        {"name": "app-service", "type": "delegate", "port": 8080, "requires": ["auth-service"]},
         {"name": "auth-service", "type": "platform", "role": "auth", "port": 8081, "requires": []},
         {
             "name": "identity-service",

{csrd_utils-0.3.57 → csrd_utils-0.3.59}/src/csrd_utils/templates/platform-auth-service/{{cookiecutter.__service_name_snake}}/views/unversioned/auth_view.py

@@ -22,6 +22,30 @@ class VerifyRequest(BaseModel):
     token: str
 
 
+class TokenResponse(BaseModel):
+    """JWT token issuance response."""
+
+    access_token: str
+    token_type: str
+    expires_in: int
+
+
+class VerifyClaims(BaseModel):
+    """JWT claim fields returned by verify endpoint."""
+
+    sub: str
+    user_name: str
+    authorities: list[str]
+    roles: list[str]
+
+
+class TokenVerifyResponse(BaseModel):
+    """Token verification response."""
+
+    valid: bool
+    claims: VerifyClaims
+
+
 def _make_verifier() -> JWTAuthenticator:
     return JWTAuthenticator(
         key=StaticKeyProvider(settings.jwt_secret),
@@ -57,10 +81,10 @@ async def _validate_credentials(username: str, password: str) -> list[str]:
     return list(user.get("roles", []))
 
 
-@router.post("/token")
+@router.post("/token", response_model=TokenResponse)
 async def issue_token(
     payload: TokenRequest, token_repo: TokenRepositoryDep
-) -> dict[str, str | int | list[str]]:
+) -> TokenResponse:
     roles = await _validate_credentials(payload.username, payload.password)
 
     now = datetime.now(UTC)
@@ -75,19 +99,21 @@ async def issue_token(
     }
     token = jwt.encode(claims, settings.jwt_secret, algorithm=settings.jwt_algorithm)
     await token_repo.record_issued_token(token=token, subject=payload.username)
-    return {"access_token": token, "token_type": "bearer", "expires_in": settings.jwt_ttl_seconds}
+    return TokenResponse(
+        access_token=token, token_type="bearer", expires_in=settings.jwt_ttl_seconds
+    )
 
 
-@router.post("/verify")
-async def verify_token(request: Request, payload: VerifyRequest) -> dict[str, object]:
+@router.post("/verify", response_model=TokenVerifyResponse)
+async def verify_token(request: Request, payload: VerifyRequest) -> TokenVerifyResponse:
     verifier = _make_verifier()
     claims = await verifier(request, payload.token)
-    return {
-        "valid": True,
-        "claims": {
-            "sub": claims.sub,
-            "user_name": claims.user_name,
-            "authorities": claims.authorities,
-            "roles": claims.authorities,
-        },
-    }
+    return TokenVerifyResponse(
+        valid=True,
+        claims=VerifyClaims(
+            sub=claims.sub,
+            user_name=claims.user_name,
+            authorities=claims.authorities,
+            roles=claims.authorities,
+        ),
+    )

{csrd_utils-0.3.57 → csrd_utils-0.3.59}/src/csrd_utils/templates/platform-identity-service/{{cookiecutter.__service_name_snake}}/views/unversioned/users_view.py

@@ -20,21 +20,43 @@ class AssignRoleRequest(BaseModel):
     role: str
 
 
-@router.get("/users/{user_id}")
-async def get_user(user_id: str, repo: UserRepositoryDep) -> dict[str, str]:
+class UserInfo(BaseModel):
+    """User information."""
+
+    id: str
+    username: str
+    created_at: str
+
+
+class UserRolesResponse(BaseModel):
+    """User roles response."""
+
+    user_id: str
+    roles: list[str]
+
+
+class VerifyCredentialsResponse(BaseModel):
+    """Credentials verification response."""
+
+    valid: bool
+    user: UserInfo
+
+
+@router.get("/users/{user_id}", response_model=UserInfo)
+async def get_user(user_id: str, repo: UserRepositoryDep) -> UserInfo:
     user = await repo.get_user(user_id)
     if user is None:
         raise HTTPException(status_code=404, detail="user not found")
-    return user
+    return UserInfo(**user)
 
 
-@router.get("/users/{user_id}/roles")
-async def get_user_roles(user_id: str, repo: UserRepositoryDep) -> dict[str, object]:
+@router.get("/users/{user_id}/roles", response_model=UserRolesResponse)
+async def get_user_roles(user_id: str, repo: UserRepositoryDep) -> UserRolesResponse:
     user = await repo.get_user(user_id)
     if user is None:
         raise HTTPException(status_code=404, detail="user not found")
     roles = await repo.get_roles(user_id)
-    return {"user_id": user_id, "roles": roles}
+    return UserRolesResponse(user_id=user_id, roles=roles)
 
 
 @router.post("/users/{user_id}/roles", status_code=204)
@@ -45,19 +67,23 @@ async def assign_role(user_id: str, payload: AssignRoleRequest, repo: UserReposi
     await repo.assign_role(user_id, payload.role)
 
 
-@router.post("/verify-credentials")
+@router.post("/verify-credentials", response_model=VerifyCredentialsResponse)
 async def verify_credentials(
     repo: UserRepositoryDep, payload: VerifyCredentialsRequest
-) -> dict[str, object]:
-    user = await repo.verify_credentials(payload.username, payload.password)
-    if user is None:
+) -> VerifyCredentialsResponse:
+    user_data = await repo.verify_credentials(payload.username, payload.password)
+    if user_data is None:
         raise HTTPException(status_code=401, detail="invalid credentials")
-    return {"valid": True, "user": user}
+    return VerifyCredentialsResponse(
+        valid=True,
+        user=UserInfo(**user_data),
+    )
 
 
-@router.post("/signup")
-async def create_user(repo: UserRepositoryDep, payload: SignupRequest) -> dict[str, str]:
+@router.post("/signup", response_model=UserInfo)
+async def create_user(repo: UserRepositoryDep, payload: SignupRequest) -> UserInfo:
     try:
-        return await repo.signup(payload.username, payload.password)
+        user_data = await repo.signup(payload.username, payload.password)
+        return UserInfo(**user_data)
     except ValueError as exc:
         raise HTTPException(status_code=409, detail=str(exc)) from exc