chore: add jiff-0_2

Author: davidbarsky

Cargo.lock

@@ -15,13 +15,15 @@ version = "7.0.17"
 
 [features]
 apollo_persisted_queries = ["lru", "sha2"]
-apollo_tracing = ["chrono"]
+apollo_tracing = []
 email-validator = ["fast_chemail"]
 cbor = ["serde_cbor"]
 chrono-duration = ["chrono", "iso8601"]
+jiff-0_2 = ["dep:jiff"]
+jiff-tz = ["jiff-0_2", "dep:jiff-tzdb"]
 dataloader = ["futures-channel", "lru"]
 decimal = ["rust_decimal"]
-default = ["email-validator", "tempfile", "playground", "graphiql"]
+default = ["email-validator", "tempfile", "playground", "graphiql", "chrono"]
 password-strength-validator = ["zxcvbn"]
 string_number = []
 tokio-sync = ["tokio"]
@@ -81,6 +83,10 @@ chrono = { version = "0.4.37", optional = true, default-features = false, featur
   "std",
 ] }
 chrono-tz = { version = "0.10.0", optional = true }
+jiff = { version = "0.2", optional = true, default-features = false, features = [
+  "std",
+] }
+jiff-tzdb = { version = "0.1", optional = true }
 fast_chemail = { version = "0.9.6", optional = true }
 hashbrown = { version = "0.16", optional = true }
 iso8601 = { version = "0.6.1", optional = true }

Cargo.toml

@@ -1,9 +1,14 @@
 use std::sync::Arc;
 
-use chrono::{DateTime, Utc};
 use futures_util::lock::Mutex;
 use serde::{Serialize, Serializer, ser::SerializeMap};
 
+// Timestamp abstraction to support both chrono and jiff
+#[cfg(all(feature = "jiff-0_2", not(feature = "chrono")))]
+use jiff::Timestamp;
+#[cfg(feature = "chrono")]
+use chrono::{DateTime, Utc};
+
 use crate::{
     Response, ServerResult, Value,
     extensions::{
@@ -12,13 +17,56 @@ use crate::{
     value,
 };
 
+// Type alias for timestamp type based on enabled features
+#[cfg(all(feature = "jiff-0_2", not(feature = "chrono")))]
+type TimestampType = Timestamp;
+#[cfg(feature = "chrono")]
+type TimestampType = DateTime<Utc>;
+
+// Helper functions to abstract timestamp operations
+#[cfg(all(feature = "jiff-0_2", not(feature = "chrono")))]
+mod timestamp_ops {
+    use jiff::Timestamp;
+
+    pub fn now() -> Timestamp {
+        Timestamp::now()
+    }
+
+    pub fn to_rfc3339(ts: &Timestamp) -> String {
+        ts.to_string()
+    }
+
+    pub fn duration_nanos(start: &Timestamp, end: &Timestamp) -> Option<i64> {
+        let duration = end.duration_since(*start);
+        // SignedDuration::as_nanos() returns i128, convert to i64
+        duration.as_nanos().try_into().ok()
+    }
+}
+
+#[cfg(feature = "chrono")]
+mod timestamp_ops {
+    use chrono::{DateTime, Utc};
+
+    pub fn now() -> DateTime<Utc> {
+        Utc::now()
+    }
+
+    pub fn to_rfc3339(ts: &DateTime<Utc>) -> String {
+        ts.to_rfc3339()
+    }
+
+    pub fn duration_nanos(start: &DateTime<Utc>, end: &DateTime<Utc>) -> Option<i64> {
+        (*end - *start).num_nanoseconds()
+    }
+}
+
 struct ResolveState {
     path: Vec<String>,
     field_name: String,
     parent_type: String,
     return_type: String,
-    start_time: DateTime<Utc>,
-    end_time: DateTime<Utc>,
+    start_time: TimestampType,
+    end_time: TimestampType,
     start_offset: i64,
 }
 
@@ -32,7 +80,7 @@ impl Serialize for ResolveState {
         map.serialize_entry("startOffset", &self.start_offset)?;
         map.serialize_entry(
             "duration",
-            &(self.end_time - self.start_time).num_nanoseconds(),
+            &timestamp_ops::duration_nanos(&self.start_time, &self.end_time),
         )?;
         map.end()
     }
@@ -53,17 +101,17 @@ impl ExtensionFactory for ApolloTracing {
     fn create(&self) -> Arc<dyn Extension> {
         Arc::new(ApolloTracingExtension {
             inner: Mutex::new(Inner {
-                start_time: Utc::now(),
-                end_time: Utc::now(),
+                start_time: timestamp_ops::now(),
+                end_time: timestamp_ops::now(),
                 resolves: Default::default(),
             }),
         })
     }
 }
 
 struct Inner {
-    start_time: DateTime<Utc>,
-    end_time: DateTime<Utc>,
+    start_time: TimestampType,
+    end_time: TimestampType,
     resolves: Vec<ResolveState>,
 }
 
@@ -79,21 +127,21 @@ impl Extension for ApolloTracingExtension {
         operation_name: Option<&str>,
         next: NextExecute<'_>,
     ) -> Response {
-        self.inner.lock().await.start_time = Utc::now();
+        self.inner.lock().await.start_time = timestamp_ops::now();
         let resp = next.run(ctx, operation_name).await;
 
         let mut inner = self.inner.lock().await;
-        inner.end_time = Utc::now();
+        inner.end_time = timestamp_ops::now();
         inner
             .resolves
             .sort_by(|a, b| a.start_offset.cmp(&b.start_offset));
         resp.extension(
             "tracing",
             value!({
                 "version": 1,
-                "startTime": inner.start_time.to_rfc3339(),
-                "endTime": inner.end_time.to_rfc3339(),
-                "duration": (inner.end_time - inner.start_time).num_nanoseconds(),
+                "startTime": timestamp_ops::to_rfc3339(&inner.start_time),
+                "endTime": timestamp_ops::to_rfc3339(&inner.end_time),
+                "duration": timestamp_ops::duration_nanos(&inner.start_time, &inner.end_time),
                 "execution": {
                     "resolvers": inner.resolves
                 }
@@ -111,13 +159,13 @@ impl Extension for ApolloTracingExtension {
         let field_name = info.path_node.field_name().to_string();
         let parent_type = info.parent_type.to_string();
         let return_type = info.return_type.to_string();
-        let start_time = Utc::now();
-        let start_offset = (start_time - self.inner.lock().await.start_time)
-            .num_nanoseconds()
-            .unwrap();
+        let start_time = timestamp_ops::now();
+        let query_start_time = self.inner.lock().await.start_time;
+        let start_offset = timestamp_ops::duration_nanos(&query_start_time, &start_time)
+            .unwrap_or(0);
 
         let res = next.run(ctx, info).await;
-        let end_time = Utc::now();
+        let end_time = timestamp_ops::now();
 
         self.inner.lock().await.resolves.push(ResolveState {
             path,

src/extensions/apollo_tracing.rs

@@ -129,6 +129,19 @@ impl CursorType for chrono::DateTime<chrono::Utc> {
     }
 }
 
+#[cfg(feature = "jiff-0_2")]
+impl CursorType for jiff::Timestamp {
+    type Error = jiff::Error;
+
+    fn decode_cursor(s: &str) -> Result<Self, Self::Error> {
+        s.parse()
+    }
+
+    fn encode_cursor(&self) -> String {
+        self.to_string()
+    }
+}
+
 #[cfg(feature = "uuid")]
 impl CursorType for uuid::Uuid {
     type Error = uuid::Error;

src/types/connection/cursor.rs

@@ -66,6 +66,35 @@ impl ScalarType for UtcDateTime {
     }
 }
 
+#[cfg(all(feature = "jiff-0_2", not(feature = "chrono")))]
+#[Scalar(internal, name = "DateTime")]
+impl ScalarType for UtcDateTime {
+    fn parse(value: Value) -> InputValueResult<Self> {
+        match &value {
+            Value::String(s) => {
+                // Parse as jiff::Timestamp, then convert to bson::DateTime via milliseconds
+                let timestamp: jiff::Timestamp = s
+                    .parse()
+                    .map_err(|e: jiff::Error| InputValueError::custom(e.to_string()))?;
+                let millis = timestamp
+                    .as_millisecond()
+                    .try_into()
+                    .map_err(|_| InputValueError::custom("timestamp out of range"))?;
+                Ok(UtcDateTime::from_millis(millis))
+            }
+            _ => Err(InputValueError::expected_type(value)),
+        }
+    }
+
+    fn to_value(&self) -> Value {
+        // Convert bson::DateTime to jiff::Timestamp via milliseconds
+        let millis = self.timestamp_millis();
+        let timestamp = jiff::Timestamp::from_millisecond(millis)
+            .expect("valid BSON timestamp should convert to jiff::Timestamp");
+        Value::String(timestamp.to_string())
+    }
+}
+
 #[Scalar(internal, name = "JSON")]
 impl ScalarType for Bson {
     fn parse(value: Value) -> InputValueResult<Self> {

src/types/external/bson.rs

@@ -4,7 +4,7 @@ use crate::{InputValueError, InputValueResult, Scalar, ScalarType, Value};
 
 #[Scalar(
     internal,
-    name = "TimeZone",
+    name = "ChronoTz",
     specified_by_url = "http://www.iana.org/time-zones"
 )]
 impl ScalarType for Tz {

src/types/external/chrono_tz.rs

@@ -7,7 +7,7 @@ use crate::{InputValueError, InputValueResult, Scalar, ScalarType, Value};
 /// The input/output is a string in RFC3339 format.
 #[Scalar(
     internal,
-    name = "DateTime",
+    name = "ChronoDateTimeFixedOffset",
     specified_by_url = "https://datatracker.ietf.org/doc/html/rfc3339"
 )]
 impl ScalarType for DateTime<FixedOffset> {
@@ -28,7 +28,7 @@ impl ScalarType for DateTime<FixedOffset> {
 /// The input/output is a string in RFC3339 format.
 #[Scalar(
     internal,
-    name = "DateTime",
+    name = "ChronoDateTimeLocal",
     specified_by_url = "https://datatracker.ietf.org/doc/html/rfc3339"
 )]
 impl ScalarType for DateTime<Local> {
@@ -49,7 +49,7 @@ impl ScalarType for DateTime<Local> {
 /// The input/output is a string in RFC3339 format.
 #[Scalar(
     internal,
-    name = "DateTime",
+    name = "ChronoDateTime",
     specified_by_url = "https://datatracker.ietf.org/doc/html/rfc3339"
 )]
 impl ScalarType for DateTime<Utc> {

src/types/external/datetime.rs

@@ -9,7 +9,7 @@ use crate::{InputValueError, InputValueResult, Scalar, ScalarType, Value};
 /// The input/output is a string in ISO8601 format.
 #[Scalar(
     internal,
-    name = "Duration",
+    name = "ChronoDuration",
     specified_by_url = "https://en.wikipedia.org/wiki/ISO_8601#Durations"
 )]
 impl ScalarType for Duration {