fix time precision + fix heartbeat responses

Author: ImShyMike

rustytime/Cargo.lock

@@ -1,7 +1,7 @@
 [package]
 name = "rustytime-server"
 description = "🕒 blazingly fast time tracking for developers"
-version = "0.5.3"
+version = "0.5.4"
 edition = "2024"
 authors = ["ImShyMike"]
 readme = "../README.md"

rustytime/Cargo.toml

@@ -71,7 +71,7 @@ async fn process_heartbeat_request(
                         data: heartbeat.into(),
                     };
                     let response_data = Json(HeartbeatApiResponseVariant::Single(response));
-                    Ok((StatusCode::CREATED, response_data).into_response())
+                    Ok((StatusCode::ACCEPTED, response_data).into_response())
                 } else {
                     Err((StatusCode::INTERNAL_SERVER_ERROR, "Internal server error")
                         .into_response())
@@ -91,11 +91,15 @@ async fn process_heartbeat_request(
         match store_heartbeats_in_db(&app_state.db_pool, new_heartbeats).await {
             Ok(heartbeats) => {
                 if heartbeats.is_empty() {
-                    let response_data = Json(HeartbeatApiResponseVariant::Multiple(vec![]));
+                    let response_data = Json(HeartbeatApiResponseVariant::Multiple(
+                        HeartbeatBulkApiResponse { responses: vec![] },
+                    ));
                     Ok((StatusCode::CREATED, response_data).into_response())
                 } else {
                     let response_data = Json(HeartbeatApiResponseVariant::Multiple(
-                        heartbeats.into_iter().map(|h| h.into()).collect(),
+                        HeartbeatBulkApiResponse {
+                            responses: heartbeats.into_iter().map(|h| h.into()).collect(),
+                        },
                     ));
                     Ok((StatusCode::CREATED, response_data).into_response())
                 }

rustytime/src/handlers/user.rs

@@ -4,6 +4,7 @@ use diesel::prelude::*;
 use diesel::sql_types::{BigInt, Date, Nullable, Text};
 use ipnetwork::IpNetwork;
 use serde::{Deserialize, Serialize};
+use serde_json::Value;
 
 use crate::schema::heartbeats;
 use crate::utils::http::parse_user_agent;
@@ -161,23 +162,39 @@ pub struct HeartbeatRequest {
 #[serde(untagged)]
 pub enum HeartbeatApiResponseVariant {
     Single(HeartbeatApiResponse),
-    Multiple(Vec<HeartbeatResponse>),
+    Multiple(HeartbeatBulkApiResponse),
 }
 
 #[derive(Serialize, Debug)]
 pub struct HeartbeatResponse {
     pub id: String,
-    pub entity: String,
-    #[serde(rename = "type")]
-    pub type_: String,
-    pub time: f64,
 }
 
 #[derive(Serialize, Debug)]
 pub struct HeartbeatApiResponse {
     pub data: HeartbeatResponse,
 }
 
+#[derive(Serialize, Debug)]
+pub struct HeartbeatBulkApiResponse {
+    pub responses: Vec<BulkResponseItem>,
+}
+
+#[derive(Serialize, Debug)]
+#[serde(untagged)]
+pub enum BulkResponsePayload {
+    Data {
+        data: HeartbeatResponse,
+    },
+    #[allow(dead_code)]
+    Errors {
+        errors: Value,
+    },
+}
+
+#[derive(Serialize, Debug)]
+pub struct BulkResponseItem(pub BulkResponsePayload, pub u16);
+
 #[derive(Queryable, Selectable, Serialize, Deserialize, Debug, Clone)]
 #[diesel(table_name = heartbeats)]
 #[diesel(check_for_backend(diesel::pg::Pg))]
@@ -260,7 +277,11 @@ pub struct SanitizedHeartbeatRequest {
 impl SanitizedHeartbeatRequest {
     pub fn from_request(request: HeartbeatRequest) -> Self {
         // Convert timestamp (seconds since epoch) to DateTime<Utc>
-        let time = DateTime::from_timestamp(request.time as i64, 0).unwrap_or_else(Utc::now);
+        let time = DateTime::from_timestamp(
+            request.time.trunc() as i64,
+            (request.time.fract() * 1e9) as u32,
+        )
+        .unwrap_or_else(Utc::now);
 
         // Handle test heartbeats
         let type_ = if request.entity == "test.txt" {
@@ -269,11 +290,17 @@ impl SanitizedHeartbeatRequest {
             request.type_
         };
 
-        // Fallback to "coding" category
+        // Parse the category
         let category = if let Some(cat) = request.category {
             Some(cat)
         } else {
-            Some("coding".to_string())
+            if type_ == "domain" || type_ == "url" {
+                Some("browsing".to_string())
+            } else if type_ == "file" && request.language.is_some() {
+                Some("coding".to_string())
+            } else {
+                None
+            }
         };
 
         // Convert dependencies and apply limits
@@ -412,22 +439,21 @@ impl NewHeartbeat {
         sanitized.into_new_heartbeat(user_id, ip_address, headers)
     }
 }
-
 impl From<Heartbeat> for HeartbeatResponse {
     fn from(heartbeat: Heartbeat) -> Self {
-        let id = heartbeat.id.to_string();
-        // Convert DateTime<Utc> to timestamp (seconds since epoch)
-        let time = heartbeat.time.timestamp() as f64;
-
         Self {
-            id,
-            entity: heartbeat.entity,
-            type_: heartbeat.type_,
-            time,
+            id: heartbeat.id.to_string(),
         }
     }
 }
 
+impl From<Heartbeat> for BulkResponseItem {
+    fn from(heartbeat: Heartbeat) -> Self {
+        let response = HeartbeatResponse::from(heartbeat);
+        BulkResponseItem(BulkResponsePayload::Data { data: response }, 201)
+    }
+}
+
 impl Heartbeat {
     pub fn count_total_heartbeats(conn: &mut PgConnection) -> QueryResult<i64> {
         heartbeats::table.count().get_result(conn)