fix: datetimes

Cargo.lock

···
 dependencies = [
  "chrono",
  "cid",
+ "jacquard-common",
  "serde",
  "serde_json",
 ]

crates/consumer/src/db/record.rs

···
             &rec.subject,
             &rec_type,
             &rec.tags,
-            &rec.created_at,
+            &rec.created_at.as_ref().to_utc(),
         ],
     )
     .await

crates/lexica/Cargo.toml

···
 [dependencies]
 chrono = { version = "0.4", features = ["serde"] }
 cid = { version = "0.11", features = ["serde"] }
+jacquard-common = { version = "0.9.5", default-features = false }
 serde = { version = "1.0", features = ["derive"] }
 serde_json = "1.0"

crates/lexica/src/app_bsky/actor.rs

···
 use crate::app_bsky::embed::External;
 use crate::app_bsky::graph::ListViewBasic;
 use crate::com_atproto::label::Label;
-use chrono::prelude::*;
+use jacquard_common::types::string::Datetime;
 use serde::{Deserialize, Serialize};
 use std::fmt::Display;
 use std::str::FromStr;
···
     #[serde(skip_serializing_if = "Option::is_none")]
     pub pronouns: Option<String>,
 
-    pub created_at: DateTime<Utc>,
+    pub created_at: Datetime,
 }
 
 #[derive(Clone, Debug, Serialize)]
···
     #[serde(skip_serializing_if = "Option::is_none")]
     pub pronouns: Option<String>,
 
-    pub created_at: DateTime<Utc>,
-    pub indexed_at: NaiveDateTime,
+    pub created_at: Datetime,
+    pub indexed_at: Datetime,
 }
 
 #[derive(Debug, Serialize)]
···
     #[serde(skip_serializing_if = "Option::is_none")]
     pub website: Option<String>,
 
-    pub created_at: DateTime<Utc>,
-    pub indexed_at: NaiveDateTime,
+    pub created_at: Datetime,
+    pub indexed_at: Datetime,
 }
 
 #[derive(Clone, Debug, Serialize)]
···
     pub issuer: String,
     pub uri: String,
     pub is_valid: bool,
-    pub created_at: DateTime<Utc>,
+    pub created_at: Datetime,
 }
 
 #[derive(Clone, Debug, Serialize)]
···
     #[serde(skip_serializing_if = "Option::is_none")]
     pub embed: Option<StatusViewEmbed>,
     #[serde(skip_serializing_if = "Option::is_none")]
-    pub expires_at: Option<DateTime<Utc>>,
+    pub expires_at: Option<Datetime>,
     #[serde(skip_serializing_if = "Option::is_none")]
     pub is_active: Option<bool>,
 }

crates/lexica/src/app_bsky/bookmark.rs

···
 use crate::app_bsky::feed::{BlockedAuthor, PostView};
 use crate::StrongRef;
-use chrono::prelude::*;
+use jacquard_common::types::string::Datetime;
 use serde::Serialize;
 
 #[derive(Clone, Debug, Serialize)]
···
 pub struct BookmarkView {
     pub subject: StrongRef,
     pub item: BookmarkViewItem,
-    pub created_at: DateTime<Utc>,
+    pub created_at: Datetime,
 }
 
 #[derive(Clone, Debug, Serialize)]

crates/lexica/src/app_bsky/embed.rs

···
 use crate::app_bsky::labeler::LabelerView;
 use crate::app_bsky::RecordStats;
 use crate::com_atproto::label::Label;
-use chrono::prelude::*;
+use jacquard_common::types::string::Datetime;
 use serde::{Deserialize, Serialize};
 
 #[derive(Clone, Debug, Deserialize, Serialize)]
···
     pub stats: RecordStats,
     #[serde(skip_serializing_if = "Option::is_none")]
     pub embeds: Option<Vec<Embed>>,
-    pub indexed_at: DateTime<Utc>,
+    pub indexed_at: Datetime,
 }
 
 #[derive(Clone, Debug, Serialize)]

crates/lexica/src/app_bsky/feed.rs

···
 use crate::app_bsky::graph::ListViewBasic;
 use crate::app_bsky::richtext::FacetMain;
 use crate::com_atproto::label::Label;
-use chrono::prelude::*;
+use jacquard_common::types::string::Datetime;
 use serde::{Deserialize, Serialize};
 use std::str::FromStr;
 
···
     #[serde(skip_serializing_if = "Option::is_none")]
     pub threadgate: Option<ThreadgateView>,
 
-    pub indexed_at: DateTime<Utc>,
+    pub indexed_at: Datetime,
 }
 
 #[derive(Debug, Serialize)]
···
     pub uri: Option<String>,
     #[serde(skip_serializing_if = "Option::is_none")]
     pub cid: Option<String>,
-    pub indexed_at: DateTime<Utc>,
+    pub indexed_at: Datetime,
 }
 
 #[derive(Debug, Serialize)]
···
     #[serde(skip_serializing_if = "Option::is_none")]
     pub content_mode: Option<GeneratorContentMode>,
 
-    pub indexed_at: DateTime<Utc>,
+    pub indexed_at: Datetime,
 }
 
 #[derive(Copy, Clone, Debug, Serialize)]
···
 #[serde(rename_all = "camelCase")]
 pub struct Like {
     pub actor: ProfileView,
-    pub created_at: DateTime<Utc>,
-    pub indexed_at: DateTime<Utc>,
+    pub created_at: Datetime,
+    pub indexed_at: Datetime,
 }
 
 #[derive(Clone, Debug, Deserialize, Serialize)]

crates/lexica/src/app_bsky/graph.rs

···
 use crate::app_bsky::feed::GeneratorView;
 use crate::app_bsky::richtext::FacetMain;
 use crate::com_atproto::label::Label;
-use chrono::prelude::*;
+use jacquard_common::types::string::Datetime;
 use serde::{Deserialize, Serialize};
 use std::str::FromStr;
 
···
     #[serde(skip_serializing_if = "Vec::is_empty")]
     pub labels: Vec<Label>,
 
-    pub indexed_at: DateTime<Utc>,
+    pub indexed_at: Datetime,
 }
 
 #[derive(Clone, Debug, Serialize)]
···
     #[serde(skip_serializing_if = "Vec::is_empty")]
     pub labels: Vec<Label>,
 
-    pub indexed_at: DateTime<Utc>,
+    pub indexed_at: Datetime,
 }
 
 #[derive(Clone, Debug, Serialize)]
···
 
     #[serde(skip_serializing_if = "Vec::is_empty")]
     pub labels: Vec<Label>,
-    pub indexed_at: DateTime<Utc>,
+    pub indexed_at: Datetime,
 }
 
 #[derive(Clone, Debug, Serialize)]
···
 
     #[serde(skip_serializing_if = "Vec::is_empty")]
     pub labels: Vec<Label>,
-    pub indexed_at: DateTime<Utc>,
+    pub indexed_at: Datetime,
 }

crates/lexica/src/app_bsky/labeler.rs

···
 use crate::app_bsky::actor::ProfileView;
 use crate::com_atproto::label::{Label, LabelValueDefinition};
 use crate::com_atproto::moderation::{ReasonType, SubjectType};
-use chrono::prelude::*;
+use jacquard_common::types::string::Datetime;
 use serde::{Deserialize, Serialize};
 
 #[derive(Clone, Default, Debug, Serialize)]
···
     pub viewer: Option<LabelerViewerState>,
     #[serde(skip_serializing_if = "Vec::is_empty")]
     pub labels: Vec<Label>,
-    pub indexed_at: DateTime<Utc>,
+    pub indexed_at: Datetime,
 }
 
 #[derive(Clone, Debug, Serialize)]
···
     #[serde(skip_serializing_if = "Option::is_none")]
     pub subject_collections: Option<Vec<String>>,
 
-    pub indexed_at: DateTime<Utc>,
+    pub indexed_at: Datetime,
 }
 
 #[derive(Clone, Debug, Deserialize, Serialize)]

crates/lexica/src/community_lexicon/bookmarks.rs

···
-use chrono::prelude::*;
+use jacquard_common::types::string::Datetime;
 use serde::{Deserialize, Serialize};
 
 #[derive(Clone, Debug, Deserialize, Serialize)]
···
     #[serde(default)]
     #[serde(skip_serializing_if = "Vec::is_empty")]
     pub tags: Vec<String>,
-    pub created_at: DateTime<Utc>,
+    pub created_at: Datetime,
 }

crates/parakeet/src/hydration/feedgen.rs

···
 use crate::hydration::map_labels;
+use crate::utils::DateTimeExt;
 use crate::xrpc::cdn::BskyCdn;
 use lexica::app_bsky::actor::ProfileView;
 use lexica::app_bsky::feed::{GeneratorContentMode, GeneratorView, GeneratorViewerState};
···
         labels: map_labels(labels),
         viewer,
         content_mode,
-        indexed_at: feedgen.created_at,
+        indexed_at: feedgen.created_at.into_jacquard(),
     }
 }
 

crates/parakeet/src/hydration/labeler.rs

···
 use crate::hydration::{map_labels, StatefulHydrator};
+use crate::utils::DateTimeExt;
 use lexica::app_bsky::actor::ProfileView;
 use lexica::app_bsky::labeler::{
     LabelerPolicy, LabelerView, LabelerViewDetailed, LabelerViewerState,
···
         like_count: likes.unwrap_or_default() as i64,
         viewer,
         labels: map_labels(labels),
-        indexed_at: labeler.indexed_at.and_utc(),
+        indexed_at: labeler.indexed_at.into_jacquard(),
     }
 }
 
···
         subject_types,
         subject_collections,
         labels: map_labels(labels),
-        indexed_at: labeler.indexed_at.and_utc(),
+        indexed_at: labeler.indexed_at.into_jacquard(),
     }
 }
 

crates/parakeet/src/hydration/list.rs

···
 use crate::db::ListStateRet;
 use crate::hydration::{map_labels, StatefulHydrator};
+use crate::utils::DateTimeExt;
 use crate::xrpc::cdn::BskyCdn;
 use lexica::app_bsky::actor::ProfileView;
 use lexica::app_bsky::graph::{ListPurpose, ListView, ListViewBasic, ListViewerState};
···
         list_item_count,
         viewer,
         labels: map_labels(labels),
-        indexed_at: list.created_at,
+        indexed_at: list.created_at.into_jacquard(),
     })
 }
 
···
         list_item_count,
         viewer,
         labels: map_labels(labels),
-        indexed_at: list.created_at,
+        indexed_at: list.created_at.into_jacquard(),
     })
 }
 

crates/parakeet/src/hydration/posts.rs

···
 use crate::db::PostStateRet;
 use crate::hydration::{map_labels, StatefulHydrator};
+use crate::utils::DateTimeExt;
 use lexica::app_bsky::actor::ProfileViewBasic;
 use lexica::app_bsky::embed::Embed;
 use lexica::app_bsky::feed::{
···
         labels: map_labels(labels),
         viewer,
         threadgate,
-        indexed_at: post.created_at,
+        indexed_at: post.created_at.into_jacquard(),
     }
 }
 
···
                             by: profiles_hydrated.get(&by).cloned()?,
                             uri: Some(uri),
                             cid: None,
-                            indexed_at: at,
+                            indexed_at: at.into_jacquard(),
                         }))
                     }
                     RawFeedItem::Pin { .. } => Some(FeedViewPostReason::Pin),

crates/parakeet/src/hydration/profile.rs

···
 use crate::db::ProfileStateRet;
 use crate::hydration::map_labels;
 use crate::loaders::ProfileLoaderRet;
+use crate::utils::DateTimeExt;
 use crate::xrpc::cdn::BskyCdn;
-use chrono::prelude::*;
-use chrono::TimeDelta;
+use chrono::{prelude::*, TimeDelta};
 use lexica::app_bsky::actor::*;
 use lexica::app_bsky::embed::External;
 use lexica::app_bsky::graph::ListViewBasic;
···
                 issuer: entry.verifier,
                 uri: entry.at_uri,
                 is_valid,
-                created_at: entry.created_at,
+                created_at: entry.created_at.into_jacquard(),
             }
         })
         .collect()
···
         status: s,
         record: status.record,
         embed,
-        expires_at,
+        expires_at: expires_at.map(|v| v.into_jacquard()),
         is_active,
     })
 }
···
         verification,
         status,
         pronouns: profile.pronouns,
-        created_at: profile.created_at.and_utc(),
+        created_at: profile.created_at.into_jacquard(),
     }
 }
 
···
         verification,
         status,
         pronouns: profile.pronouns,
-        created_at: profile.created_at.and_utc(),
-        indexed_at: profile.indexed_at,
+        created_at: profile.created_at.into_jacquard(),
+        indexed_at: profile.indexed_at.into_jacquard(),
     }
 }
 
···
         status,
         pronouns: profile.pronouns,
         website: profile.website,
-        created_at: profile.created_at.and_utc(),
-        indexed_at: profile.indexed_at,
+        created_at: profile.created_at.into_jacquard(),
+        indexed_at: profile.indexed_at.into_jacquard(),
     }
 }
 

crates/parakeet/src/hydration/starter_packs.rs

···
 use crate::hydration::{map_labels, StatefulHydrator};
+use crate::utils::DateTimeExt;
 use lexica::app_bsky::actor::ProfileViewBasic;
 use lexica::app_bsky::feed::GeneratorView;
 use lexica::app_bsky::graph::{ListViewBasic, StarterPackView, StarterPackViewBasic};
···
         joined_week_count: 0,
         joined_all_time_count: 0,
         labels: map_labels(labels),
-        indexed_at: starter_pack.created_at,
+        indexed_at: starter_pack.created_at.into_jacquard(),
     }
 }
 
···
         joined_week_count: 0,
         joined_all_time_count: 0,
         labels: map_labels(labels),
-        indexed_at: starter_pack.created_at,
+        indexed_at: starter_pack.created_at.into_jacquard(),
     }
 }
 

crates/parakeet/src/main.rs

···
 mod hydration;
 mod instrumentation;
 mod loaders;
+mod utils;
 mod xrpc;
 
 #[derive(Clone)]

crates/parakeet/src/utils.rs

···
+use chrono::{DateTime, NaiveDateTime, Utc};
+use jacquard_common::types::string::Datetime;
+
+pub trait DateTimeExt {
+    fn into_jacquard(self) -> Datetime;
+}
+
+impl DateTimeExt for DateTime<Utc> {
+    #[inline(always)]
+    fn into_jacquard(self) -> Datetime {
+        Datetime::new(self.fixed_offset())
+    }
+}
+
+impl DateTimeExt for NaiveDateTime {
+    #[inline(always)]
+    fn into_jacquard(self) -> Datetime {
+        self.and_utc().into_jacquard()
+    }
+}

crates/parakeet/src/xrpc/app_bsky/bookmark.rs

···
 use crate::hydration::StatefulHydrator;
+use crate::utils::DateTimeExt;
 use crate::xrpc::error::XrpcResult;
 use crate::xrpc::extract::{AtpAcceptLabelers, AtpAuth};
 use crate::xrpc::{datetime_cursor, CursorQuery};
···
             Some(BookmarkView {
                 subject,
                 item,
-                created_at: bookmark.created_at,
+                created_at: bookmark.created_at.into_jacquard(),
             })
         })
         .collect();

crates/parakeet/src/xrpc/app_bsky/feed/likes.rs

···
 use crate::hydration::posts::RawFeedItem;
 use crate::hydration::StatefulHydrator;
+use crate::utils::DateTimeExt;
 use crate::xrpc::error::{Error, XrpcResult};
 use crate::xrpc::extract::{AtpAcceptLabelers, AtpAuth};
 use crate::xrpc::{datetime_cursor, normalise_at_uri, ActorWithCursorQuery};
···
 
             Some(Like {
                 actor,
-                created_at,
-                indexed_at: indexed_at.and_utc(),
+                created_at: created_at.into_jacquard(),
+                indexed_at: indexed_at.into_jacquard(),
             })
         })
         .collect();

crates/parakeet/src/xrpc/community_lexicon/bookmarks.rs

···
+use crate::utils::DateTimeExt;
 use crate::xrpc::datetime_cursor;
 use crate::xrpc::error::XrpcResult;
 use crate::xrpc::extract::AtpAuth;
···
         .map(|bookmark| Bookmark {
             subject: bookmark.subject,
             tags: bookmark.tags.into(),
-            created_at: bookmark.created_at,
+            created_at: bookmark.created_at.into_jacquard(),
         })
         .collect();