fix: fixed revalidation time strings

Author: arctic-hen7

examples/core/state_generation/src/templates/revalidation.rs

@@ -1,5 +1,4 @@
 use perseus::{RenderFnResultWithCause, Template};
-use std::time::Duration;
 use sycamore::prelude::{view, Html, Scope, View};
 
 #[perseus::make_rx(PageStateRx)]
@@ -18,7 +17,7 @@ pub fn get_template<G: Html>() -> Template<G> {
     Template::new("revalidation")
         .template(revalidation_page)
         // This page will revalidate every five seconds (and so the time displayed will be updated)
-        .revalidate_after(Duration::new(5, 0))
+        .revalidate_after("5s")
         // This is an alternative method of revalidation that uses logic, which will be executed
         // every itme a user tries to load this page. For that reason, this should NOT do
         // long-running work, as requests will be delayed. If both this

packages/perseus/src/template/core.rs

@@ -14,6 +14,8 @@ use crate::utils::provide_context_signal_replace;
 use crate::utils::AsyncFnReturn;
 #[cfg(not(target_arch = "wasm32"))]
 use crate::utils::ComputedDuration;
+use crate::utils::PerseusDuration; /* We do actually want this in both the engine and the
+                                     * browser */
 use crate::Html;
 #[cfg(not(target_arch = "wasm32"))]
 use crate::Request;
@@ -23,7 +25,6 @@ use crate::SsrNode;
 use futures::Future;
 #[cfg(not(target_arch = "wasm32"))]
 use http::header::HeaderMap;
-use std::time::Duration;
 use sycamore::prelude::{Scope, View};
 #[cfg(not(target_arch = "wasm32"))]
 use sycamore::utils::hydrate::with_no_hydration_context;
@@ -675,8 +676,14 @@ impl<G: Html> Template<G> {
     ///    - y: year (365 days always, leap years ignored, if you want them add
     ///      them as days)
     #[cfg(not(target_arch = "wasm32"))]
-    pub fn revalidate_after<I: Into<Duration>>(mut self, val: I) -> Template<G> {
-        self.revalidate_after = Some(ComputedDuration::new(val));
+    pub fn revalidate_after<I: PerseusDuration>(mut self, val: I) -> Template<G> {
+        let computed_duration = match val.into_computed() {
+            Ok(val) => val,
+            // This is fine, because this will be checked when we try to build the app (i.e. it'll
+            // show up before runtime)
+            Err(_) => panic!("invalid revalidation interval"),
+        };
+        self.revalidate_after = Some(computed_duration);
         self
     }
     /// Enables the *revalidation* strategy (time variant). This takes a time
@@ -691,7 +698,7 @@ impl<G: Html> Template<G> {
     ///    - y: year (365 days always, leap years ignored, if you want them add
     ///      them as days)
     #[cfg(target_arch = "wasm32")]
-    pub fn revalidate_after<I: Into<Duration>>(self, _val: I) -> Template<G> {
+    pub fn revalidate_after<I: PerseusDuration>(self, _val: I) -> Template<G> {
         self
     }
 

packages/perseus/src/utils/decode_time_str.rs

@@ -1,92 +1,138 @@
-use chrono::Utc;
-use std::{convert::TryFrom, time};
-
-/// Represents a duration that can be computed relative to the current time.
-#[derive(Debug, Clone)]
-pub struct ComputedDuration(chrono::Duration);
-
-impl ComputedDuration {
-    /// Creates a new [`ComputedDuration`] from the given duration-like type.
-    pub fn new<I: Into<time::Duration>>(duration: I) -> Self {
-        let duration = chrono::Duration::from_std(duration.into()).unwrap();
-        Self(duration)
+#[cfg(not(target_arch = "wasm32"))]
+mod engine {
+    use super::InvalidDuration;
+    use chrono::Utc;
+    use std::time;
+
+    /// Represents a duration that can be computed relative to the current time.
+    /// This should be created through [`PerseusDuration::into_computed`] only.
+    #[derive(Debug, Clone)]
+    pub struct ComputedDuration(chrono::Duration);
+
+    impl ComputedDuration {
+        /// Get the timestamp of the duration added to the current time.
+        pub fn compute_timestamp(&self) -> String {
+            let current = Utc::now();
+            let datetime = current + self.0;
+            datetime.to_rfc3339()
+        }
     }
 
-    /// Get the timestamp of the duration added to the current time.
-    pub fn compute_timestamp(&self) -> String {
-        let current = Utc::now();
-        let datetime = current + self.0;
-        datetime.to_rfc3339()
+    /// A trait that represents anything we'll accept for specifying durations
+    /// for revalidation. Anything that implements thus must be able to be
+    /// transformed into a [`ComputedDuration`];
+    pub trait PerseusDuration {
+        /// Converts this into a `[ComputedDuration]` for use in Perseus'
+        /// internal revalidation systems.
+        fn into_computed(self) -> Result<ComputedDuration, InvalidDuration>;
     }
-}
 
-/// A simpler representation of a duration based on individual components.
-///
-/// Note that months are assumed to be 30 days long, and years 365 days long.
-#[derive(Default, Debug)]
-pub struct Duration {
-    years: i64,
-    months: i64,
-    weeks: i64,
-    days: i64,
-    hours: i64,
-    minutes: i64,
-    seconds: i64,
-}
+    // We'll accept strings, and standard library durations.
+    // We don't accept Chrono durations because that would create a difference to
+    // the browser dummy API (since Chrono is only used on the engine side), and
+    // Chrono durations can be trivially converted into standard ones.
+    impl PerseusDuration for chrono::Duration {
+        fn into_computed(self) -> Result<ComputedDuration, InvalidDuration> {
+            Ok(ComputedDuration(self))
+        }
+    }
+    impl PerseusDuration for &str {
+        // NOTE: Logic to define how we parse time strings is here
+        fn into_computed(self) -> Result<ComputedDuration, InvalidDuration> {
+            let mut duration = chrono::Duration::zero();
 
-/// An error type for invalid `String` durations.
-pub struct InvalidDuration;
+            // A working variable to store the '123' part of an interval until we reach the
+            // indicator and can do the full conversion
+            let mut curr_duration_length = String::new();
 
-impl From<Duration> for time::Duration {
-    fn from(duration: Duration) -> Self {
-        let duration = chrono::Duration::seconds(duration.seconds)
-            + chrono::Duration::minutes(duration.minutes)
-            + chrono::Duration::hours(duration.hours)
-            + chrono::Duration::days(duration.days)
-            + chrono::Duration::weeks(duration.weeks)
-            + chrono::Duration::days(duration.months * 30)  // Assumed length of a month
-            + chrono::Duration::days(duration.years * 365); // Assumed length of a year
-
-        duration.to_std().unwrap()
-    }
-}
+            for c in self.chars() {
+                // If we have a number, append it to the working cache
+                // If we have an indicator character, we'll match it to a duration
+                if c.is_numeric() {
+                    curr_duration_length.push(c);
+                } else {
+                    let interval_length: i64 = curr_duration_length.parse().unwrap(); // It's just a string of numbers, we know more than the compiler
+                    if interval_length <= 0 {
+                        return Err(InvalidDuration);
+                    }
 
-impl TryFrom<&str> for Duration {
-    type Error = InvalidDuration;
-
-    fn try_from(value: &str) -> Result<Self, Self::Error> {
-        let mut duration = Self::default();
-
-        // A working variable to store the '123' part of an interval until we reach the
-        // indicator and can do the full conversion
-        let mut curr_duration_length = String::new();
-
-        for c in value.chars() {
-            // If we have a number, append it to the working cache
-            // If we have an indicator character, we'll match it to a duration
-            if c.is_numeric() {
-                curr_duration_length.push(c);
-            } else {
-                let interval_length: i64 = curr_duration_length.parse().unwrap(); // It's just a string of numbers, we know more than the compiler
-                if interval_length <= 0 {
-                    return Err(InvalidDuration);
-                }
+                    match c {
+                        's' => duration = duration + chrono::Duration::seconds(interval_length),
+                        'm' => duration = duration + chrono::Duration::minutes(interval_length),
+                        'h' => duration = duration + chrono::Duration::hours(interval_length),
+                        'd' => duration = duration + chrono::Duration::days(interval_length),
+                        'w' => duration = duration + chrono::Duration::weeks(interval_length),
+                        'M' => duration = duration + chrono::Duration::days(interval_length * 30), /* Assumed length of a month */
+                        'y' => duration = duration + chrono::Duration::days(interval_length * 365), /* Assumed length of a year */
+                        _ => return Err(InvalidDuration),
+                    };
 
-                match c {
-                    's' if duration.seconds == 0 => duration.seconds = interval_length,
-                    'm' if duration.minutes == 0 => duration.minutes = interval_length,
-                    'h' if duration.hours == 0 => duration.hours = interval_length,
-                    'd' if duration.days == 0 => duration.days = interval_length,
-                    'w' if duration.weeks == 0 => duration.weeks = interval_length,
-                    'M' if duration.months == 0 => duration.months = interval_length,
-                    'y' if duration.years == 0 => duration.years = interval_length,
-                    _ => return Err(InvalidDuration),
-                };
-
-                curr_duration_length = String::new();
+                    curr_duration_length = String::new();
+                }
             }
+
+            Ok(ComputedDuration(duration))
         }
+    }
+    impl PerseusDuration for time::Duration {
+        fn into_computed(self) -> Result<ComputedDuration, InvalidDuration> {
+            let duration = chrono::Duration::from_std(self).map_err(|_| InvalidDuration)?;
+            Ok(ComputedDuration(duration))
+        }
+    }
+}
+#[cfg(target_arch = "wasm32")]
+mod browser {
+    use super::InvalidDuration;
+    use std::time;
+
+    /// Represents a duration that can be computed relative to the current time.
+    /// This should be created through [`PerseusDuration::into_computed`] only.
+    #[derive(Debug, Clone)]
+    pub struct ComputedDuration;
 
-        Ok(duration)
+    /// A trait that represents anything we'll accept for specifying durations
+    /// for revalidation. Anything that implements thus must be able to be
+    /// transformed into a [`ComputedDuration`];
+    pub trait PerseusDuration {
+        /// Converts this into a `[ComputedDuration]` for use in Perseus'
+        /// internal revalidation systems.
+        fn into_computed(self) -> Result<ComputedDuration, InvalidDuration>
+        where
+            Self: Sized,
+        {
+            // In the browser, this function should never be called
+            unreachable!("computed durations can only be created on the engine-side")
+        }
     }
+
+    // Dummy implementations for the browser follow (we only need this for generic
+    // validation)
+    impl PerseusDuration for &str {}
+    impl PerseusDuration for time::Duration {}
 }
+
+/// An error type for invalid durations.
+#[derive(Debug)]
+pub struct InvalidDuration;
+
+#[cfg(target_arch = "wasm32")]
+pub use browser::{ComputedDuration, PerseusDuration};
+#[cfg(not(target_arch = "wasm32"))]
+pub use engine::{ComputedDuration, PerseusDuration};
+
+// // We can convert from our duration type into the standard library's
+// impl From<Duration> for time::Duration {
+//     fn from(duration: Duration) -> Self {
+//         let duration = chrono::Duration::seconds(duration.seconds)
+//             + chrono::Duration::minutes(duration.minutes)
+//             + chrono::Duration::hours(duration.hours)
+//             + chrono::Duration::days(duration.days)
+//             + chrono::Duration::weeks(duration.weeks)
+//             + chrono::Duration::days(duration.months * 30)  // Assumed length
+// of a month             + chrono::Duration::days(duration.years * 365); //
+// Assumed length of a year
+
+//         duration.to_std().unwrap()
+//     }
+// }

packages/perseus/src/utils/mod.rs

@@ -4,7 +4,6 @@ mod cache_res;
 #[cfg(target_arch = "wasm32")]
 mod checkpoint;
 mod context;
-#[cfg(not(target_arch = "wasm32"))]
 mod decode_time_str;
 #[cfg(target_arch = "wasm32")]
 mod fetch;
@@ -20,8 +19,7 @@ pub use cache_res::{cache_fallible_res, cache_res};
 #[cfg(target_arch = "wasm32")]
 pub use checkpoint::checkpoint;
 pub(crate) use context::provide_context_signal_replace;
-#[cfg(not(target_arch = "wasm32"))]
-pub use decode_time_str::{ComputedDuration, Duration, InvalidDuration};
+pub use decode_time_str::{ComputedDuration, InvalidDuration, PerseusDuration}; /* These have dummy equivalents for the browser */
 #[cfg(target_arch = "wasm32")]
 pub(crate) use fetch::fetch;
 pub use path_prefix::*;