hevy 0.1.0

An async Rust client library for the Hevy public API (https://api.hevyapp.com/docs/)
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273

use serde::{Deserialize, Serialize};

use super::common::{RepRange, SetType, flexible_f64};

/// A set belonging to an exercise within a [`Routine`], as returned by the API.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct RoutineSet {
    /// Index indicating the order of the set within the exercise.
    #[serde(default)]
    pub index: u32,
    /// The type of set: one of `normal`, `warmup`, `dropset`, `failure`.
    #[serde(rename = "type", default)]
    pub r#type: String,
    /// Weight lifted, in kilograms.
    #[serde(default)]
    pub weight_kg: Option<f64>,
    /// Number of reps logged for the set.
    #[serde(default)]
    pub reps: Option<f64>,
    /// A target rep range for the set, if applicable.
    #[serde(default)]
    pub rep_range: Option<RepRange>,
    /// Number of meters logged for the set.
    #[serde(default)]
    pub distance_meters: Option<f64>,
    /// Number of seconds logged for the set.
    #[serde(default)]
    pub duration_seconds: Option<f64>,
    /// Rating of Perceived Exertion logged for the set.
    #[serde(default)]
    pub rpe: Option<f64>,
    /// Custom metric logged for the set.
    #[serde(default)]
    pub custom_metric: Option<f64>,
}

/// An exercise entry within a [`Routine`].
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct RoutineExercise {
    /// Index indicating the order of the exercise within the routine.
    #[serde(default)]
    pub index: u32,
    /// Title of the exercise.
    #[serde(default)]
    pub title: String,
    /// The rest time in seconds between sets of the exercise.
    ///
    /// The API documents this as a string but has been observed to also return
    /// a number; both are accepted.
    #[serde(default, deserialize_with = "flexible_f64")]
    pub rest_seconds: Option<f64>,
    /// Routine notes on the exercise.
    #[serde(default)]
    pub notes: Option<String>,
    /// The id of the exercise template. Can be used to fetch the full template.
    #[serde(default)]
    pub exercise_template_id: String,
    /// The id of the superset this exercise belongs to, if any.
    #[serde(default)]
    pub supersets_id: Option<u32>,
    /// The sets configured for this exercise.
    #[serde(default)]
    pub sets: Vec<RoutineSet>,
}

/// A saved workout routine/template.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct Routine {
    /// The routine ID.
    pub id: String,
    /// The routine title.
    #[serde(default)]
    pub title: String,
    /// The routine folder ID this routine belongs to, if any.
    #[serde(default)]
    pub folder_id: Option<i64>,
    /// ISO 8601 timestamp of when the routine was last updated.
    #[serde(default)]
    pub updated_at: String,
    /// ISO 8601 timestamp of when the routine was created.
    #[serde(default)]
    pub created_at: String,
    /// The exercises configured in this routine.
    #[serde(default)]
    pub exercises: Vec<RoutineExercise>,
}

/// A page of [`Routine`]s, as returned by [`crate::HevyClient::list_routines`].
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct RoutinesPage {
    /// The current page number.
    pub page: u32,
    /// The total number of pages available.
    pub page_count: u32,
    /// The routines on this page.
    #[serde(default)]
    pub routines: Vec<Routine>,
}

/// Wrapper for the single-routine response returned by `GET /v1/routines/{routineId}`.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub(crate) struct RoutineEnvelope {
    pub routine: Routine,
}

/// A set to include when creating or updating a routine's exercise.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct RoutineSetInput {
    /// The type of the set.
    #[serde(rename = "type", skip_serializing_if = "Option::is_none")]
    pub r#type: Option<SetType>,
    /// The weight in kilograms.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub weight_kg: Option<f64>,
    /// The number of repetitions.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub reps: Option<i64>,
    /// The distance in meters.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub distance_meters: Option<i64>,
    /// The duration in seconds.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub duration_seconds: Option<i64>,
    /// A custom metric for the set. Currently used for steps and floors.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub custom_metric: Option<f64>,
    /// A target rep range for the set, if applicable.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub rep_range: Option<RepRange>,
}

impl RoutineSetInput {
    /// Creates a normal set with the given weight and reps.
    pub fn normal(weight_kg: f64, reps: i64) -> Self {
        Self {
            r#type: Some(SetType::Normal),
            weight_kg: Some(weight_kg),
            reps: Some(reps),
            ..Default::default()
        }
    }
}

/// An exercise to include when creating or updating a routine.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct RoutineExerciseInput {
    /// The ID of the exercise template.
    pub exercise_template_id: String,
    /// The ID of the superset this exercise belongs to, if any.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub superset_id: Option<i64>,
    /// The rest time in seconds between sets.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub rest_seconds: Option<i64>,
    /// Additional notes for the exercise.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub notes: Option<String>,
    /// The sets configured for this exercise.
    pub sets: Vec<RoutineSetInput>,
}

impl RoutineExerciseInput {
    /// Creates a new exercise input for the given exercise template id.
    pub fn new(exercise_template_id: impl Into<String>) -> Self {
        Self {
            exercise_template_id: exercise_template_id.into(),
            superset_id: None,
            rest_seconds: None,
            notes: None,
            sets: Vec::new(),
        }
    }

    /// Appends a set to this exercise.
    pub fn with_set(mut self, set: RoutineSetInput) -> Self {
        self.sets.push(set);
        self
    }
}

/// The routine fields accepted when creating a new routine.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct NewRoutine {
    /// The title of the routine.
    pub title: String,
    /// The folder id the routine should be added to.
    ///
    /// Pass `None` to insert the routine into the default "My Routines" folder.
    #[serde(default)]
    pub folder_id: Option<i64>,
    /// Additional notes for the routine.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub notes: Option<String>,
    /// The exercises configured in this routine.
    pub exercises: Vec<RoutineExerciseInput>,
}

impl NewRoutine {
    /// Creates a new routine with the given title.
    pub fn new(title: impl Into<String>) -> Self {
        Self {
            title: title.into(),
            folder_id: None,
            notes: None,
            exercises: Vec::new(),
        }
    }

    /// Appends an exercise to this routine.
    pub fn with_exercise(mut self, exercise: RoutineExerciseInput) -> Self {
        self.exercises.push(exercise);
        self
    }
}

/// The request body used to create a new routine.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct CreateRoutineRequest {
    /// The routine to create.
    pub routine: NewRoutine,
}

impl CreateRoutineRequest {
    /// Wraps a [`NewRoutine`] in the request body envelope expected by the API.
    pub fn new(routine: NewRoutine) -> Self {
        Self { routine }
    }
}

/// The routine fields accepted when updating an existing routine.
///
/// Note that, unlike [`NewRoutine`], the folder cannot be changed via this endpoint.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct UpdatedRoutine {
    /// The title of the routine.
    pub title: String,
    /// Additional notes for the routine.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub notes: Option<String>,
    /// The exercises configured in this routine.
    pub exercises: Vec<RoutineExerciseInput>,
}

impl UpdatedRoutine {
    /// Creates a new routine update payload with the given title.
    pub fn new(title: impl Into<String>) -> Self {
        Self {
            title: title.into(),
            notes: None,
            exercises: Vec::new(),
        }
    }

    /// Appends an exercise to this routine.
    pub fn with_exercise(mut self, exercise: RoutineExerciseInput) -> Self {
        self.exercises.push(exercise);
        self
    }
}

/// The request body used to update an existing routine.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct UpdateRoutineRequest {
    /// The new state of the routine.
    pub routine: UpdatedRoutine,
}

impl UpdateRoutineRequest {
    /// Wraps an [`UpdatedRoutine`] in the request body envelope expected by the API.
    pub fn new(routine: UpdatedRoutine) -> Self {
        Self { routine }
    }
}