typespec-rust-emitter 0.5.0 → 0.7.0

package/example/output-rust/src/generated/server.rs

@@ -1,3 +1,5 @@
+#![allow(unused)]
+
 use super::types::*;
 use async_trait::async_trait;
 use axum::{http::StatusCode, Json};
@@ -11,45 +13,45 @@ pub trait Server: Send + Sync {
 
 
     /// Retrieve a list of all groups for the current account (from view_learning_group).
-    async fn groups_list(&self) -> Result<GroupsListResponse>;
+    async fn groups_list(&self, account_id: uuid::Uuid) -> Result<GroupsListResponse>;
     /// Create a new group.
-    async fn groups_create(&self, claims: Self::Claims, body: CreateGroupBody) -> Result<GroupsCreateResponse>;
+    async fn groups_create(&self, claims: Self::Claims, account_id: uuid::Uuid, body: CreateGroupBody) -> Result<GroupsCreateResponse>;
     /// Get the details of a group by its ID.
-    async fn groups_get_by_id(&self, id: i64) -> Result<GroupsGetByIdResponse>;
+    async fn groups_get_by_id(&self, account_id: uuid::Uuid, id: i64) -> Result<GroupsGetByIdResponse>;
     /// Update a group. Only provide the fields that need to be changed.
-    async fn groups_update(&self, claims: Self::Claims, id: i64, body: UpdateGroupBody) -> Result<GroupsUpdateResponse>;
+    async fn groups_update(&self, claims: Self::Claims, account_id: uuid::Uuid, id: i64, body: UpdateGroupBody) -> Result<GroupsUpdateResponse>;
     /// Soft delete a group. All subjects within the group will also be soft deleted.
-    async fn groups_delete(&self, claims: Self::Claims, id: i64) -> Result<GroupsDeleteResponse>;
+    async fn groups_delete(&self, claims: Self::Claims, account_id: uuid::Uuid, id: i64) -> Result<GroupsDeleteResponse>;
     /// Retrieve a list of subjects for a group (from view_subject_statistics).
-    async fn subjects_list(&self, group_id: i64) -> Result<SubjectsListResponse>;
+    async fn subjects_list(&self, account_id: uuid::Uuid, group_id: i64) -> Result<SubjectsListResponse>;
     /// Create a new subject within the specified group.
-    async fn subjects_create(&self, claims: Self::Claims, group_id: i64, body: CreateSubjectBody) -> Result<SubjectsCreateResponse>;
+    async fn subjects_create(&self, claims: Self::Claims, account_id: uuid::Uuid, group_id: i64, body: CreateSubjectBody) -> Result<SubjectsCreateResponse>;
     /// Get the details of a subject by its ID.
-    async fn subjects_get_by_id(&self, group_id: i64, id: i64) -> Result<SubjectsGetByIdResponse>;
+    async fn subjects_get_by_id(&self, account_id: uuid::Uuid, group_id: i64, id: i64) -> Result<SubjectsGetByIdResponse>;
     /// Update a subject. Only provide the fields that need to be changed.
-    async fn subjects_update(&self, claims: Self::Claims, group_id: i64, id: i64, body: UpdateSubjectBody) -> Result<SubjectsUpdateResponse>;
+    async fn subjects_update(&self, claims: Self::Claims, account_id: uuid::Uuid, group_id: i64, id: i64, body: UpdateSubjectBody) -> Result<SubjectsUpdateResponse>;
     /// Soft delete a subject.
-    async fn subjects_delete(&self, claims: Self::Claims, group_id: i64, id: i64) -> Result<SubjectsDeleteResponse>;
+    async fn subjects_delete(&self, claims: Self::Claims, account_id: uuid::Uuid, group_id: i64, id: i64) -> Result<SubjectsDeleteResponse>;
     /// Start a new study session for the subject.
 /// The server creates a Log (status=Starting) and the first Timelog.
 /// Returns 409 if the subject already has a session in Starting or Paused status.
-    async fn sessions_start(&self, claims: Self::Claims, subject_id: i64, body: SessionNoteBody) -> Result<SessionsStartResponse>;
+    async fn sessions_start(&self, claims: Self::Claims, account_id: uuid::Uuid, subject_id: i64, body: SessionNoteBody) -> Result<SessionsStartResponse>;
     /// Pause the currently running session (transition from Starting to Paused).
 /// The server closes the current Timelog (sets stoppedAt and calculates durationInSeconds).
 /// Returns 409 if the session is not in the Starting state.
-    async fn sessions_pause(&self, claims: Self::Claims, subject_id: i64, log_id: i64) -> Result<SessionsPauseResponse>;
+    async fn sessions_pause(&self, claims: Self::Claims, account_id: uuid::Uuid, subject_id: i64, log_id: i64) -> Result<SessionsPauseResponse>;
     /// Resume a paused session (transition from Paused to Starting).
 /// The server creates a new Timelog.
 /// Returns 409 if the session is not in the Paused state.
-    async fn sessions_resume(&self, claims: Self::Claims, subject_id: i64, log_id: i64) -> Result<SessionsResumeResponse>;
+    async fn sessions_resume(&self, claims: Self::Claims, account_id: uuid::Uuid, subject_id: i64, log_id: i64) -> Result<SessionsResumeResponse>;
     /// End the session (transition from Starting or Paused to Stopped).
 /// The server closes the current Timelog if it is running, and updates Log.stoppedAt.
 /// Returns 409 if the session is already Stopped.
-    async fn sessions_stop(&self, claims: Self::Claims, subject_id: i64, log_id: i64, body: SessionNoteBody) -> Result<SessionsStopResponse>;
+    async fn sessions_stop(&self, claims: Self::Claims, account_id: uuid::Uuid, subject_id: i64, log_id: i64, body: SessionNoteBody) -> Result<SessionsStopResponse>;
 }
 pub enum GroupsListResponse {
     Ok(Json<Vec<GroupStatistics>>),
-    Unauthorized,
+    Unauthorized(Json<ApiError>),
 }
 
 impl IntoResponse for GroupsListResponse {
@@ -57,15 +59,15 @@ impl IntoResponse for GroupsListResponse {
         match self {
 
             GroupsListResponse::Ok(body) => (StatusCode::OK, body).into_response(),
-            GroupsListResponse::Unauthorized => StatusCode::UNAUTHORIZED.into_response(),
+            GroupsListResponse::Unauthorized(body) => (StatusCode::UNAUTHORIZED, body).into_response(),
         }
     }
 }
 
 pub enum GroupsCreateResponse {
     Created(Json<Group>),
-    BadRequest,
-    Unauthorized,
+    BadRequest(Json<ValidationError>),
+    Unauthorized(Json<ApiError>),
 }
 
 impl IntoResponse for GroupsCreateResponse {
@@ -73,16 +75,16 @@ impl IntoResponse for GroupsCreateResponse {
         match self {
 
             GroupsCreateResponse::Created(body) => (StatusCode::CREATED, body).into_response(),
-            GroupsCreateResponse::BadRequest => StatusCode::BAD_REQUEST.into_response(),
-            GroupsCreateResponse::Unauthorized => StatusCode::UNAUTHORIZED.into_response(),
+            GroupsCreateResponse::BadRequest(body) => (StatusCode::BAD_REQUEST, body).into_response(),
+            GroupsCreateResponse::Unauthorized(body) => (StatusCode::UNAUTHORIZED, body).into_response(),
         }
     }
 }
 
 pub enum GroupsGetByIdResponse {
     Ok(Json<GroupStatistics>),
-    Unauthorized,
-    NotFound,
+    Unauthorized(Json<ApiError>),
+    NotFound(Json<NotFoundError>),
 }
 
 impl IntoResponse for GroupsGetByIdResponse {
@@ -90,17 +92,17 @@ impl IntoResponse for GroupsGetByIdResponse {
         match self {
 
             GroupsGetByIdResponse::Ok(body) => (StatusCode::OK, body).into_response(),
-            GroupsGetByIdResponse::Unauthorized => StatusCode::UNAUTHORIZED.into_response(),
-            GroupsGetByIdResponse::NotFound => StatusCode::NOT_FOUND.into_response(),
+            GroupsGetByIdResponse::Unauthorized(body) => (StatusCode::UNAUTHORIZED, body).into_response(),
+            GroupsGetByIdResponse::NotFound(body) => (StatusCode::NOT_FOUND, body).into_response(),
         }
     }
 }
 
 pub enum GroupsUpdateResponse {
     Ok(Json<Group>),
-    BadRequest,
-    Unauthorized,
-    NotFound,
+    BadRequest(Json<ValidationError>),
+    Unauthorized(Json<ApiError>),
+    NotFound(Json<NotFoundError>),
 }
 
 impl IntoResponse for GroupsUpdateResponse {
@@ -108,17 +110,17 @@ impl IntoResponse for GroupsUpdateResponse {
         match self {
 
             GroupsUpdateResponse::Ok(body) => (StatusCode::OK, body).into_response(),
-            GroupsUpdateResponse::BadRequest => StatusCode::BAD_REQUEST.into_response(),
-            GroupsUpdateResponse::Unauthorized => StatusCode::UNAUTHORIZED.into_response(),
-            GroupsUpdateResponse::NotFound => StatusCode::NOT_FOUND.into_response(),
+            GroupsUpdateResponse::BadRequest(body) => (StatusCode::BAD_REQUEST, body).into_response(),
+            GroupsUpdateResponse::Unauthorized(body) => (StatusCode::UNAUTHORIZED, body).into_response(),
+            GroupsUpdateResponse::NotFound(body) => (StatusCode::NOT_FOUND, body).into_response(),
         }
     }
 }
 
 pub enum GroupsDeleteResponse {
     NoContent,
-    Unauthorized,
-    NotFound,
+    Unauthorized(Json<ApiError>),
+    NotFound(Json<NotFoundError>),
 }
 
 impl IntoResponse for GroupsDeleteResponse {
@@ -126,16 +128,16 @@ impl IntoResponse for GroupsDeleteResponse {
         match self {
 
             GroupsDeleteResponse::NoContent => StatusCode::NO_CONTENT.into_response(),
-            GroupsDeleteResponse::Unauthorized => StatusCode::UNAUTHORIZED.into_response(),
-            GroupsDeleteResponse::NotFound => StatusCode::NOT_FOUND.into_response(),
+            GroupsDeleteResponse::Unauthorized(body) => (StatusCode::UNAUTHORIZED, body).into_response(),
+            GroupsDeleteResponse::NotFound(body) => (StatusCode::NOT_FOUND, body).into_response(),
         }
     }
 }
 
 pub enum SubjectsListResponse {
     Ok(Json<Vec<SubjectStatistics>>),
-    Unauthorized,
-    NotFound,
+    Unauthorized(Json<ApiError>),
+    NotFound(Json<NotFoundError>),
 }
 
 impl IntoResponse for SubjectsListResponse {
@@ -143,17 +145,17 @@ impl IntoResponse for SubjectsListResponse {
         match self {
 
             SubjectsListResponse::Ok(body) => (StatusCode::OK, body).into_response(),
-            SubjectsListResponse::Unauthorized => StatusCode::UNAUTHORIZED.into_response(),
-            SubjectsListResponse::NotFound => StatusCode::NOT_FOUND.into_response(),
+            SubjectsListResponse::Unauthorized(body) => (StatusCode::UNAUTHORIZED, body).into_response(),
+            SubjectsListResponse::NotFound(body) => (StatusCode::NOT_FOUND, body).into_response(),
         }
     }
 }
 
 pub enum SubjectsCreateResponse {
     Created(Json<Subject>),
-    BadRequest,
-    Unauthorized,
-    NotFound,
+    BadRequest(Json<ValidationError>),
+    Unauthorized(Json<ApiError>),
+    NotFound(Json<NotFoundError>),
 }
 
 impl IntoResponse for SubjectsCreateResponse {
@@ -161,17 +163,17 @@ impl IntoResponse for SubjectsCreateResponse {
         match self {
 
             SubjectsCreateResponse::Created(body) => (StatusCode::CREATED, body).into_response(),
-            SubjectsCreateResponse::BadRequest => StatusCode::BAD_REQUEST.into_response(),
-            SubjectsCreateResponse::Unauthorized => StatusCode::UNAUTHORIZED.into_response(),
-            SubjectsCreateResponse::NotFound => StatusCode::NOT_FOUND.into_response(),
+            SubjectsCreateResponse::BadRequest(body) => (StatusCode::BAD_REQUEST, body).into_response(),
+            SubjectsCreateResponse::Unauthorized(body) => (StatusCode::UNAUTHORIZED, body).into_response(),
+            SubjectsCreateResponse::NotFound(body) => (StatusCode::NOT_FOUND, body).into_response(),
         }
     }
 }
 
 pub enum SubjectsGetByIdResponse {
     Ok(Json<SubjectStatistics>),
-    Unauthorized,
-    NotFound,
+    Unauthorized(Json<ApiError>),
+    NotFound(Json<NotFoundError>),
 }
 
 impl IntoResponse for SubjectsGetByIdResponse {
@@ -179,17 +181,17 @@ impl IntoResponse for SubjectsGetByIdResponse {
         match self {
 
             SubjectsGetByIdResponse::Ok(body) => (StatusCode::OK, body).into_response(),
-            SubjectsGetByIdResponse::Unauthorized => StatusCode::UNAUTHORIZED.into_response(),
-            SubjectsGetByIdResponse::NotFound => StatusCode::NOT_FOUND.into_response(),
+            SubjectsGetByIdResponse::Unauthorized(body) => (StatusCode::UNAUTHORIZED, body).into_response(),
+            SubjectsGetByIdResponse::NotFound(body) => (StatusCode::NOT_FOUND, body).into_response(),
         }
     }
 }
 
 pub enum SubjectsUpdateResponse {
     Ok(Json<Subject>),
-    BadRequest,
-    Unauthorized,
-    NotFound,
+    BadRequest(Json<ValidationError>),
+    Unauthorized(Json<ApiError>),
+    NotFound(Json<NotFoundError>),
 }
 
 impl IntoResponse for SubjectsUpdateResponse {
@@ -197,17 +199,17 @@ impl IntoResponse for SubjectsUpdateResponse {
         match self {
 
             SubjectsUpdateResponse::Ok(body) => (StatusCode::OK, body).into_response(),
-            SubjectsUpdateResponse::BadRequest => StatusCode::BAD_REQUEST.into_response(),
-            SubjectsUpdateResponse::Unauthorized => StatusCode::UNAUTHORIZED.into_response(),
-            SubjectsUpdateResponse::NotFound => StatusCode::NOT_FOUND.into_response(),
+            SubjectsUpdateResponse::BadRequest(body) => (StatusCode::BAD_REQUEST, body).into_response(),
+            SubjectsUpdateResponse::Unauthorized(body) => (StatusCode::UNAUTHORIZED, body).into_response(),
+            SubjectsUpdateResponse::NotFound(body) => (StatusCode::NOT_FOUND, body).into_response(),
         }
     }
 }
 
 pub enum SubjectsDeleteResponse {
     NoContent,
-    Unauthorized,
-    NotFound,
+    Unauthorized(Json<ApiError>),
+    NotFound(Json<NotFoundError>),
 }
 
 impl IntoResponse for SubjectsDeleteResponse {
@@ -215,17 +217,17 @@ impl IntoResponse for SubjectsDeleteResponse {
         match self {
 
             SubjectsDeleteResponse::NoContent => StatusCode::NO_CONTENT.into_response(),
-            SubjectsDeleteResponse::Unauthorized => StatusCode::UNAUTHORIZED.into_response(),
-            SubjectsDeleteResponse::NotFound => StatusCode::NOT_FOUND.into_response(),
+            SubjectsDeleteResponse::Unauthorized(body) => (StatusCode::UNAUTHORIZED, body).into_response(),
+            SubjectsDeleteResponse::NotFound(body) => (StatusCode::NOT_FOUND, body).into_response(),
         }
     }
 }
 
 pub enum SessionsStartResponse {
     Created(Json<SessionOpenedResponse>),
-    Unauthorized,
-    NotFound,
-    Conflict,
+    Unauthorized(Json<ApiError>),
+    NotFound(Json<NotFoundError>),
+    Conflict(Json<ConflictError>),
 }
 
 impl IntoResponse for SessionsStartResponse {
@@ -233,18 +235,18 @@ impl IntoResponse for SessionsStartResponse {
         match self {
 
             SessionsStartResponse::Created(body) => (StatusCode::CREATED, body).into_response(),
-            SessionsStartResponse::Unauthorized => StatusCode::UNAUTHORIZED.into_response(),
-            SessionsStartResponse::NotFound => StatusCode::NOT_FOUND.into_response(),
-            SessionsStartResponse::Conflict => StatusCode::CONFLICT.into_response(),
+            SessionsStartResponse::Unauthorized(body) => (StatusCode::UNAUTHORIZED, body).into_response(),
+            SessionsStartResponse::NotFound(body) => (StatusCode::NOT_FOUND, body).into_response(),
+            SessionsStartResponse::Conflict(body) => (StatusCode::CONFLICT, body).into_response(),
         }
     }
 }
 
 pub enum SessionsPauseResponse {
     Ok(Json<SessionClosedResponse>),
-    Unauthorized,
-    NotFound,
-    Conflict,
+    Unauthorized(Json<ApiError>),
+    NotFound(Json<NotFoundError>),
+    Conflict(Json<ConflictError>),
 }
 
 impl IntoResponse for SessionsPauseResponse {
@@ -252,18 +254,18 @@ impl IntoResponse for SessionsPauseResponse {
         match self {
 
             SessionsPauseResponse::Ok(body) => (StatusCode::OK, body).into_response(),
-            SessionsPauseResponse::Unauthorized => StatusCode::UNAUTHORIZED.into_response(),
-            SessionsPauseResponse::NotFound => StatusCode::NOT_FOUND.into_response(),
-            SessionsPauseResponse::Conflict => StatusCode::CONFLICT.into_response(),
+            SessionsPauseResponse::Unauthorized(body) => (StatusCode::UNAUTHORIZED, body).into_response(),
+            SessionsPauseResponse::NotFound(body) => (StatusCode::NOT_FOUND, body).into_response(),
+            SessionsPauseResponse::Conflict(body) => (StatusCode::CONFLICT, body).into_response(),
         }
     }
 }
 
 pub enum SessionsResumeResponse {
     Ok(Json<SessionOpenedResponse>),
-    Unauthorized,
-    NotFound,
-    Conflict,
+    Unauthorized(Json<ApiError>),
+    NotFound(Json<NotFoundError>),
+    Conflict(Json<ConflictError>),
 }
 
 impl IntoResponse for SessionsResumeResponse {
@@ -271,18 +273,18 @@ impl IntoResponse for SessionsResumeResponse {
         match self {
 
             SessionsResumeResponse::Ok(body) => (StatusCode::OK, body).into_response(),
-            SessionsResumeResponse::Unauthorized => StatusCode::UNAUTHORIZED.into_response(),
-            SessionsResumeResponse::NotFound => StatusCode::NOT_FOUND.into_response(),
-            SessionsResumeResponse::Conflict => StatusCode::CONFLICT.into_response(),
+            SessionsResumeResponse::Unauthorized(body) => (StatusCode::UNAUTHORIZED, body).into_response(),
+            SessionsResumeResponse::NotFound(body) => (StatusCode::NOT_FOUND, body).into_response(),
+            SessionsResumeResponse::Conflict(body) => (StatusCode::CONFLICT, body).into_response(),
         }
     }
 }
 
 pub enum SessionsStopResponse {
     Ok(Json<SessionClosedResponse>),
-    Unauthorized,
-    NotFound,
-    Conflict,
+    Unauthorized(Json<ApiError>),
+    NotFound(Json<NotFoundError>),
+    Conflict(Json<ConflictError>),
 }
 
 impl IntoResponse for SessionsStopResponse {
@@ -290,9 +292,9 @@ impl IntoResponse for SessionsStopResponse {
         match self {
 
             SessionsStopResponse::Ok(body) => (StatusCode::OK, body).into_response(),
-            SessionsStopResponse::Unauthorized => StatusCode::UNAUTHORIZED.into_response(),
-            SessionsStopResponse::NotFound => StatusCode::NOT_FOUND.into_response(),
-            SessionsStopResponse::Conflict => StatusCode::CONFLICT.into_response(),
+            SessionsStopResponse::Unauthorized(body) => (StatusCode::UNAUTHORIZED, body).into_response(),
+            SessionsStopResponse::NotFound(body) => (StatusCode::NOT_FOUND, body).into_response(),
+            SessionsStopResponse::Conflict(body) => (StatusCode::CONFLICT, body).into_response(),
         }
     }
 }
@@ -304,13 +306,13 @@ use axum::Router;
 
 pub async fn groups_list_handler<S>(
     axum::extract::State(service): axum::extract::State<S>,
-
+    Path(account_id): Path<uuid::Uuid>,
 ) -> impl axum::response::IntoResponse
 where
     S: Server + Clone + Send + Sync + 'static,
     S::Claims: Send + Sync + Clone + 'static,
 {
-    let result = service.groups_list().await;
+    let result = service.groups_list(account_id).await;
     match result {
         Ok(response) => response.into_response(),
         Err(e) => (
@@ -324,13 +326,14 @@ where
 pub async fn groups_create_handler<S>(
     axum::extract::State(service): axum::extract::State<S>,
     Extension(claims): Extension<S::Claims>,
+    Path(account_id): Path<uuid::Uuid>,
     Json(payload): Json<CreateGroupBody>,
 ) -> impl axum::response::IntoResponse
 where
     S: Server + Clone + Send + Sync + 'static,
     S::Claims: Send + Sync + Clone + 'static,
 {
-    let result = service.groups_create(claims, payload).await;
+    let result = service.groups_create(claims, account_id, payload).await;
     match result {
         Ok(response) => response.into_response(),
         Err(e) => (
@@ -343,13 +346,13 @@ where
 
 pub async fn groups_get_by_id_handler<S>(
     axum::extract::State(service): axum::extract::State<S>,
-    Path(id): Path<i64>,
+    Path((account_id, id)): Path<(uuid::Uuid, i64)>,
 ) -> impl axum::response::IntoResponse
 where
     S: Server + Clone + Send + Sync + 'static,
     S::Claims: Send + Sync + Clone + 'static,
 {
-    let result = service.groups_get_by_id(id).await;
+    let result = service.groups_get_by_id(account_id, id).await;
     match result {
         Ok(response) => response.into_response(),
         Err(e) => (
@@ -363,14 +366,14 @@ where
 pub async fn groups_update_handler<S>(
     axum::extract::State(service): axum::extract::State<S>,
     Extension(claims): Extension<S::Claims>,
-    Path(id): Path<i64>,
+    Path((account_id, id)): Path<(uuid::Uuid, i64)>,
     Json(payload): Json<UpdateGroupBody>,
 ) -> impl axum::response::IntoResponse
 where
     S: Server + Clone + Send + Sync + 'static,
     S::Claims: Send + Sync + Clone + 'static,
 {
-    let result = service.groups_update(claims, id, payload).await;
+    let result = service.groups_update(claims, account_id, id, payload).await;
     match result {
         Ok(response) => response.into_response(),
         Err(e) => (
@@ -384,13 +387,13 @@ where
 pub async fn groups_delete_handler<S>(
     axum::extract::State(service): axum::extract::State<S>,
     Extension(claims): Extension<S::Claims>,
-    Path(id): Path<i64>,
+    Path((account_id, id)): Path<(uuid::Uuid, i64)>,
 ) -> impl axum::response::IntoResponse
 where
     S: Server + Clone + Send + Sync + 'static,
     S::Claims: Send + Sync + Clone + 'static,
 {
-    let result = service.groups_delete(claims, id).await;
+    let result = service.groups_delete(claims, account_id, id).await;
     match result {
         Ok(response) => response.into_response(),
         Err(e) => (
@@ -403,13 +406,13 @@ where
 
 pub async fn subjects_list_handler<S>(
     axum::extract::State(service): axum::extract::State<S>,
-    Path(group_id): Path<i64>,
+    Path((account_id, group_id)): Path<(uuid::Uuid, i64)>,
 ) -> impl axum::response::IntoResponse
 where
     S: Server + Clone + Send + Sync + 'static,
     S::Claims: Send + Sync + Clone + 'static,
 {
-    let result = service.subjects_list(group_id).await;
+    let result = service.subjects_list(account_id, group_id).await;
     match result {
         Ok(response) => response.into_response(),
         Err(e) => (
@@ -423,14 +426,14 @@ where
 pub async fn subjects_create_handler<S>(
     axum::extract::State(service): axum::extract::State<S>,
     Extension(claims): Extension<S::Claims>,
-    Path(group_id): Path<i64>,
+    Path((account_id, group_id)): Path<(uuid::Uuid, i64)>,
     Json(payload): Json<CreateSubjectBody>,
 ) -> impl axum::response::IntoResponse
 where
     S: Server + Clone + Send + Sync + 'static,
     S::Claims: Send + Sync + Clone + 'static,
 {
-    let result = service.subjects_create(claims, group_id, payload).await;
+    let result = service.subjects_create(claims, account_id, group_id, payload).await;
     match result {
         Ok(response) => response.into_response(),
         Err(e) => (
@@ -443,13 +446,13 @@ where
 
 pub async fn subjects_get_by_id_handler<S>(
     axum::extract::State(service): axum::extract::State<S>,
-    Path((group_id, id)): Path<(i64, i64)>,
+    Path((account_id, group_id, id)): Path<(uuid::Uuid, i64, i64)>,
 ) -> impl axum::response::IntoResponse
 where
     S: Server + Clone + Send + Sync + 'static,
     S::Claims: Send + Sync + Clone + 'static,
 {
-    let result = service.subjects_get_by_id(group_id, id).await;
+    let result = service.subjects_get_by_id(account_id, group_id, id).await;
     match result {
         Ok(response) => response.into_response(),
         Err(e) => (
@@ -463,14 +466,14 @@ where
 pub async fn subjects_update_handler<S>(
     axum::extract::State(service): axum::extract::State<S>,
     Extension(claims): Extension<S::Claims>,
-    Path((group_id, id)): Path<(i64, i64)>,
+    Path((account_id, group_id, id)): Path<(uuid::Uuid, i64, i64)>,
     Json(payload): Json<UpdateSubjectBody>,
 ) -> impl axum::response::IntoResponse
 where
     S: Server + Clone + Send + Sync + 'static,
     S::Claims: Send + Sync + Clone + 'static,
 {
-    let result = service.subjects_update(claims, group_id, id, payload).await;
+    let result = service.subjects_update(claims, account_id, group_id, id, payload).await;
     match result {
         Ok(response) => response.into_response(),
         Err(e) => (
@@ -484,13 +487,13 @@ where
 pub async fn subjects_delete_handler<S>(
     axum::extract::State(service): axum::extract::State<S>,
     Extension(claims): Extension<S::Claims>,
-    Path((group_id, id)): Path<(i64, i64)>,
+    Path((account_id, group_id, id)): Path<(uuid::Uuid, i64, i64)>,
 ) -> impl axum::response::IntoResponse
 where
     S: Server + Clone + Send + Sync + 'static,
     S::Claims: Send + Sync + Clone + 'static,
 {
-    let result = service.subjects_delete(claims, group_id, id).await;
+    let result = service.subjects_delete(claims, account_id, group_id, id).await;
     match result {
         Ok(response) => response.into_response(),
         Err(e) => (
@@ -504,14 +507,14 @@ where
 pub async fn sessions_start_handler<S>(
     axum::extract::State(service): axum::extract::State<S>,
     Extension(claims): Extension<S::Claims>,
-    Path(subject_id): Path<i64>,
+    Path((account_id, subject_id)): Path<(uuid::Uuid, i64)>,
     Json(payload): Json<SessionNoteBody>,
 ) -> impl axum::response::IntoResponse
 where
     S: Server + Clone + Send + Sync + 'static,
     S::Claims: Send + Sync + Clone + 'static,
 {
-    let result = service.sessions_start(claims, subject_id, payload).await;
+    let result = service.sessions_start(claims, account_id, subject_id, payload).await;
     match result {
         Ok(response) => response.into_response(),
         Err(e) => (
@@ -525,13 +528,13 @@ where
 pub async fn sessions_pause_handler<S>(
     axum::extract::State(service): axum::extract::State<S>,
     Extension(claims): Extension<S::Claims>,
-    Path((subject_id, log_id)): Path<(i64, i64)>,
+    Path((account_id, subject_id, log_id)): Path<(uuid::Uuid, i64, i64)>,
 ) -> impl axum::response::IntoResponse
 where
     S: Server + Clone + Send + Sync + 'static,
     S::Claims: Send + Sync + Clone + 'static,
 {
-    let result = service.sessions_pause(claims, subject_id, log_id).await;
+    let result = service.sessions_pause(claims, account_id, subject_id, log_id).await;
     match result {
         Ok(response) => response.into_response(),
         Err(e) => (
@@ -545,13 +548,13 @@ where
 pub async fn sessions_resume_handler<S>(
     axum::extract::State(service): axum::extract::State<S>,
     Extension(claims): Extension<S::Claims>,
-    Path((subject_id, log_id)): Path<(i64, i64)>,
+    Path((account_id, subject_id, log_id)): Path<(uuid::Uuid, i64, i64)>,
 ) -> impl axum::response::IntoResponse
 where
     S: Server + Clone + Send + Sync + 'static,
     S::Claims: Send + Sync + Clone + 'static,
 {
-    let result = service.sessions_resume(claims, subject_id, log_id).await;
+    let result = service.sessions_resume(claims, account_id, subject_id, log_id).await;
     match result {
         Ok(response) => response.into_response(),
         Err(e) => (
@@ -565,14 +568,14 @@ where
 pub async fn sessions_stop_handler<S>(
     axum::extract::State(service): axum::extract::State<S>,
     Extension(claims): Extension<S::Claims>,
-    Path((subject_id, log_id)): Path<(i64, i64)>,
+    Path((account_id, subject_id, log_id)): Path<(uuid::Uuid, i64, i64)>,
     Json(payload): Json<SessionNoteBody>,
 ) -> impl axum::response::IntoResponse
 where
     S: Server + Clone + Send + Sync + 'static,
     S::Claims: Send + Sync + Clone + 'static,
 {
-    let result = service.sessions_stop(claims, subject_id, log_id, payload).await;
+    let result = service.sessions_stop(claims, account_id, subject_id, log_id, payload).await;
     match result {
         Ok(response) => response.into_response(),
         Err(e) => (
@@ -591,24 +594,24 @@ where
 {
     let mut router = Router::new();
     let public = Router::new()
-        .route("/groups", get(groups_list_handler::<S>))
-        .route("/groups/{id}", get(groups_get_by_id_handler::<S>))
-        .route("/groups/{groupId}/subjects", get(subjects_list_handler::<S>))
-        .route("/groups/{groupId}/subjects/{id}", get(subjects_get_by_id_handler::<S>))
+        .route("/accounts/{accountId}/learning/groups", get(groups_list_handler::<S>))
+        .route("/accounts/{accountId}/learning/groups/{id}", get(groups_get_by_id_handler::<S>))
+        .route("/accounts/{accountId}/learning/groups/{groupId}/subjects", get(subjects_list_handler::<S>))
+        .route("/accounts/{accountId}/learning/groups/{groupId}/subjects/{id}", get(subjects_get_by_id_handler::<S>))
         ;
     router = router.merge(public);
     let protected = Router::new()
-        .route("/groups", post(groups_create_handler::<S>))
-        .route("/groups/{id}", patch(groups_update_handler::<S>))
-        .route("/groups/{id}", delete(groups_delete_handler::<S>))
-        .route("/groups/{groupId}/subjects", post(subjects_create_handler::<S>))
-        .route("/groups/{groupId}/subjects/{id}", patch(subjects_update_handler::<S>))
-        .route("/groups/{groupId}/subjects/{id}", delete(subjects_delete_handler::<S>))
-        .route("/subjects/{subjectId}/sessions", post(sessions_start_handler::<S>))
-        .route("/subjects/{subjectId}/sessions/{logId}/pause", post(sessions_pause_handler::<S>))
-        .route("/subjects/{subjectId}/sessions/{logId}/resume", post(sessions_resume_handler::<S>))
-        .route("/subjects/{subjectId}/sessions/{logId}/stop", post(sessions_stop_handler::<S>))
+        .route("/accounts/{accountId}/learning/groups", post(groups_create_handler::<S>))
+        .route("/accounts/{accountId}/learning/groups/{id}", patch(groups_update_handler::<S>))
+        .route("/accounts/{accountId}/learning/groups/{id}", delete(groups_delete_handler::<S>))
+        .route("/accounts/{accountId}/learning/groups/{groupId}/subjects", post(subjects_create_handler::<S>))
+        .route("/accounts/{accountId}/learning/groups/{groupId}/subjects/{id}", patch(subjects_update_handler::<S>))
+        .route("/accounts/{accountId}/learning/groups/{groupId}/subjects/{id}", delete(subjects_delete_handler::<S>))
+        .route("/accounts/{accountId}/learning/subjects/{subjectId}/sessions", post(sessions_start_handler::<S>))
+        .route("/accounts/{accountId}/learning/subjects/{subjectId}/sessions/{logId}/pause", post(sessions_pause_handler::<S>))
+        .route("/accounts/{accountId}/learning/subjects/{subjectId}/sessions/{logId}/resume", post(sessions_resume_handler::<S>))
+        .route("/accounts/{accountId}/learning/subjects/{subjectId}/sessions/{logId}/stop", post(sessions_stop_handler::<S>))
         ;
     router = router.merge(middleware(protected));
     router.with_state(service)
-}
+}

package/example/output-rust/src/generated/types.rs

@@ -1,3 +1,5 @@
+#![allow(unused)]
+
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize, thiserror::Error)]
 #[error("{code}: {message}")]
 pub struct ApiError {
@@ -291,3 +293,4 @@ impl Default for HexColor {
     Self(String::new())
   }
 }
+

package/example/package-lock.json

@@ -17,7 +17,7 @@
       }
     },
     "..": {
-      "version": "0.5.0",
+      "version": "0.6.0",
       "license": "MIT",
       "devDependencies": {
         "@types/node": "latest",