@rivetkit/engine 1.0.0

package/packages/util/src/check.rs

@@ -0,0 +1,222 @@
+use lazy_static::lazy_static;
+use regex::{Regex, RegexBuilder};
+
+pub const MAX_IDENT_LEN: usize = 64;
+// TODO: Do we still need long idents?
+pub const MAX_IDENT_LONG_LEN: usize = 64;
+pub const MAX_DISPLAY_NAME_LEN: usize = 24;
+pub const MAX_DISPLAY_NAME_LONG_LEN: usize = 128;
+pub const MAX_BIOGRAPHY_LEN: usize = 200;
+pub const MAX_NEW_LINES: usize = 5;
+pub const MAX_DOMAIN_LEN: usize = 255;
+pub const MAX_DENO_NAME_LEN: usize = 32;
+
+lazy_static! {
+	static ref BCRYPT: Regex = RegexBuilder::new(r#"^\$2[ayb]?\$[0-9]{2}\$[A-Za-z0-9\./]+$"#)
+		.build()
+		.unwrap();
+}
+
+/// Determines if the given string is a safe identifier.
+///
+/// All characters must be lowercase alphanumeric or a dash without a repeating double dash.
+///
+/// Double dashes are used as separators in DNS and path components internally.
+pub fn ident(s: impl AsRef<str>) -> bool {
+	ident_with_len(s, false, MAX_IDENT_LEN)
+}
+
+pub fn ident_long(s: impl AsRef<str>) -> bool {
+	ident_with_len(s, false, MAX_IDENT_LONG_LEN)
+}
+
+pub fn ident_lenient(s: impl AsRef<str>) -> bool {
+	ident_with_len(s, true, MAX_IDENT_LONG_LEN)
+}
+
+pub fn ident_with_len(s: impl AsRef<str>, lenient: bool, len: usize) -> bool {
+	let s = s.as_ref();
+	!s.is_empty()
+		&& s.len() <= len
+		&& !s.starts_with('-')
+		&& !s.ends_with('-')
+		&& s.chars().all(|c| match c {
+			'0'..='9' | 'a'..='z' | '-' => true,
+			'A'..='Z' | '_' if lenient => true,
+			_ => false,
+		}) && (lenient || !s.contains("--"))
+}
+
+/// Same as `ident` but without the length requirement.
+pub fn docker_ident(s: impl AsRef<str>) -> bool {
+	let s = s.as_ref();
+	s.chars().all(|c| match c {
+		'0'..='9' | 'a'..='z' | '-' | '_' => true,
+		_ => false,
+	}) && !s.is_empty()
+		&& !s.starts_with('-')
+		&& !s.ends_with('-')
+}
+
+/// Determines if the given string can be used as a display name.
+///
+/// We allow all unicode characters limited to 24 bytes, not graphemes.
+pub fn display_name(s: impl AsRef<str>) -> bool {
+	display_name_with_len(s, MAX_DISPLAY_NAME_LEN)
+}
+
+/// See `display_name`. Limited to 64 bytes.
+pub fn display_name_long(s: impl AsRef<str>) -> bool {
+	display_name_with_len(s, MAX_DISPLAY_NAME_LONG_LEN)
+}
+
+fn display_name_with_len(s: impl AsRef<str>, len: usize) -> bool {
+	let s = s.as_ref();
+
+	if s.is_empty() || s.len() > len {
+		return false;
+	}
+
+	let chars: Vec<char> = s.chars().collect();
+
+	// Check for non-space whitespace
+	if chars.iter().any(|c| c != &' ' && c.is_whitespace()) {
+		return false;
+	}
+
+	// Check for trailing whitespace
+	if let (Some(first), Some(last)) = (chars.first(), chars.last()) {
+		if first.is_whitespace() || last.is_whitespace() {
+			return false;
+		}
+	}
+
+	// Check for more than 1 whitespace in a row
+	let mut last_whitespace = false;
+	for c in chars {
+		let is_whitespace = c.is_whitespace();
+
+		if is_whitespace && last_whitespace {
+			return false;
+		}
+
+		last_whitespace = is_whitespace;
+	}
+
+	true
+}
+
+/// Determines if the given string can be used as a biography.
+///
+/// We allow all unicode characters limited to 200 bytes, not graphemes.
+pub fn biography(s: impl AsRef<str>) -> bool {
+	let s = s.as_ref();
+
+	if s.len() > MAX_BIOGRAPHY_LEN {
+		return false;
+	}
+
+	let chars: Vec<char> = s.chars().collect();
+
+	// Check for whitespace that isn't a space or new line
+	if chars
+		.iter()
+		.any(|c| c != &' ' && c != &'\n' && c.is_whitespace())
+	{
+		return false;
+	}
+
+	// Only allow a total of MAX_NEW_LINES new lines
+	if chars
+		.iter()
+		.fold(0, |s, c| s + if c == &'\n' { 1 } else { 0 })
+		> MAX_NEW_LINES
+	{
+		return false;
+	}
+
+	true
+}
+
+/// Checks if a domain is valid.
+pub fn domain(s: impl AsRef<str>) -> bool {
+	let s = s.as_ref();
+
+	!s.is_empty()
+		&& s.len() <= MAX_DOMAIN_LEN
+		&& s.chars().all(|c| match c {
+			'0'..='9' | 'a'..='z' | '-' | '.' => true,
+			_ => false,
+		})
+}
+
+/// Checks if a string is a valid bcrypt hash.
+pub fn bcrypt(s: impl AsRef<str>) -> bool {
+	let s = s.as_ref();
+
+	BCRYPT.is_match(s)
+}
+
+/// Checks if a string is a valid Deno name.
+pub fn deno_name(s: impl AsRef<str>) -> bool {
+	let s = s.as_ref();
+	!s.is_empty()
+		&& s.len() <= MAX_DENO_NAME_LEN
+		&& !s.starts_with('_')
+		&& !s.ends_with('_')
+		&& s.chars().all(|c| match c {
+			'0'..='9' | 'a'..='z' | '_' => true,
+			_ => false,
+		}) && !s.contains("__")
+}
+
+#[cfg(test)]
+mod tests {
+	#[test]
+	fn ident() {
+		assert!(super::ident("x".repeat(super::MAX_IDENT_LEN)));
+		assert!(!super::ident("x".repeat(super::MAX_IDENT_LEN + 1)));
+		assert!(super::ident("test"));
+		assert!(super::ident("test-123"));
+		assert!(super::ident("test-123-abc"));
+		assert!(!super::ident("test--123"));
+		assert!(!super::ident("test-123-"));
+		assert!(!super::ident("-test-123"));
+		assert!(!super::ident("test_123"));
+		assert!(!super::ident("test-ABC"));
+	}
+
+	#[test]
+	fn ident_long() {
+		assert!(super::ident_long("x".repeat(super::MAX_IDENT_LONG_LEN)));
+		assert!(!super::ident_long(
+			"x".repeat(super::MAX_IDENT_LONG_LEN + 1)
+		));
+		assert!(super::ident_long("test"));
+		assert!(super::ident_long("test-123"));
+		assert!(super::ident_long("test-123-abc"));
+		assert!(!super::ident_long("test--123"));
+		assert!(!super::ident_long("test-123-"));
+		assert!(!super::ident_long("-test-123"));
+		assert!(!super::ident_long("test_123"));
+		assert!(!super::ident("test-ABC"));
+	}
+
+	#[test]
+	fn ident_lenient() {
+		assert!(super::ident_lenient("x".repeat(super::MAX_IDENT_LONG_LEN)));
+		assert!(!super::ident_lenient(
+			"x".repeat(super::MAX_IDENT_LONG_LEN + 1)
+		));
+		assert!(super::ident_lenient("test"));
+		assert!(super::ident_lenient("test-123"));
+		assert!(super::ident_lenient("test-123-abc"));
+		assert!(super::ident_lenient("test--123"));
+		assert!(!super::ident_lenient("test-123-"));
+		assert!(!super::ident_lenient("-test-123"));
+		assert!(super::ident_lenient("test_123"));
+		assert!(super::ident_lenient("test_123-abc"));
+		assert!(super::ident_lenient("test_123_abc"));
+		assert!(super::ident_lenient("test-ABC"));
+	}
+}

package/packages/util/src/duration.rs

@@ -0,0 +1,77 @@
+use chrono::Duration;
+
+pub trait ToChrono {
+	fn to_chrono(self) -> Duration;
+}
+
+impl ToChrono for i64 {
+	fn to_chrono(self) -> Duration {
+		Duration::milliseconds(self)
+	}
+}
+
+pub const fn seconds(v: i64) -> i64 {
+	v * 1000
+}
+
+pub const fn minutes(v: i64) -> i64 {
+	seconds(v) * 60
+}
+
+pub const fn hours(v: i64) -> i64 {
+	minutes(v) * 60
+}
+
+pub const fn days(v: i64) -> i64 {
+	hours(v) * 24
+}
+
+/// Returns a short readable duration string for a given duration of milliseconds (500000 -> 5m 20s)
+pub fn format(v: i64, with_ms: bool) -> String {
+	if with_ms && v < seconds(1) {
+		return format!("{}ms", v);
+	}
+
+	let seconds = v % minutes(1) / seconds(1);
+	let minutes = v % hours(1) / minutes(1);
+	let hours = v % days(1) / hours(1);
+	let days = v / days(1);
+
+	let segments = IntoIterator::into_iter([days, hours, minutes])
+		.enumerate()
+		.filter_map(|(i, x)| {
+			if x != 0 {
+				let suffix = match i {
+					0 => "d",
+					1 => "h",
+					2 => "m",
+					_ => "null",
+				};
+
+				Some(format!("{}{} ", x, suffix))
+			} else {
+				None
+			}
+		})
+		.collect::<String>();
+
+	format!("{}{}s", segments, seconds)
+}
+
+#[cfg(test)]
+mod test {
+	use super::*;
+
+	#[test]
+	fn duration() {
+		assert_eq!(days(5), 5 * 24 * 60 * 60 * 1000);
+	}
+
+	#[test]
+	fn format_duration() {
+		assert_eq!(
+			format(days(12) + hours(25) + minutes(0) + seconds(3), false).as_str(),
+			"13d 1h 3s"
+		);
+	}
+}

package/packages/util/src/faker.rs

@@ -0,0 +1,81 @@
+use rand::{Rng, thread_rng};
+
+pub const IDENT_CHARSET: &[u8] = b"abcdefghijklmnopqrstuvwxyz1234567890-";
+pub const IDENT_CHARSET_ALPHANUM: &[u8] = b"abcdefghijklmnopqrstuvwxyz1234567890";
+
+/// Generates a random Rivet-safe identifier. See `check::ident`.
+pub fn ident() -> String {
+	let mut rng = thread_rng();
+	let len = rng.gen_range((crate::check::MAX_IDENT_LEN - 4)..=crate::check::MAX_IDENT_LEN);
+
+	// TODO: Use `rand::distributions::Uniform` and `.sample` instead of calling `gen_range` multiple times
+	// Generate body including dash
+	let body = std::iter::repeat_with(|| {
+		let idx = rng.gen_range(0..IDENT_CHARSET.len());
+		IDENT_CHARSET[idx] as char
+	})
+	.take(len - 2)
+	.collect::<String>();
+	let body = body.replace("--", "x-"); // Remove double-dashes
+
+	// Choose alphanum characters for the start and finish since name IDs can't start or finish
+	// with a dash
+	let start = {
+		let idx = rng.gen_range(0..IDENT_CHARSET_ALPHANUM.len());
+		IDENT_CHARSET_ALPHANUM[idx] as char
+	};
+	let end = {
+		let idx = rng.gen_range(0..IDENT_CHARSET_ALPHANUM.len());
+		IDENT_CHARSET_ALPHANUM[idx] as char
+	};
+
+	format!("{}{}{}", start, body, end)
+}
+
+/// Generates a random Rivet-safe display name. See `check::display_name`.
+pub fn display_name() -> String {
+	let mut rng = thread_rng();
+	let len = rng
+		.gen_range((crate::check::MAX_DISPLAY_NAME_LEN - 4)..=crate::check::MAX_DISPLAY_NAME_LEN);
+	rng.sample_iter(rand::distributions::Alphanumeric)
+		.map(char::from)
+		.take(len)
+		.collect::<String>()
+}
+
+pub fn email() -> String {
+	format!("test-{}@rivet.gg", ident())
+}
+
+pub fn bcrypt() -> (String, String) {
+	let password = ident();
+
+	(
+		password.clone(),
+		bcrypt::hash(password, bcrypt::DEFAULT_COST).unwrap(),
+	)
+}
+
+pub fn ip_addr_v4() -> std::net::Ipv4Addr {
+	let mut rng = thread_rng();
+	std::net::Ipv4Addr::new(
+		rng.r#gen::<u8>(),
+		rng.r#gen::<u8>(),
+		rng.r#gen::<u8>(),
+		rng.r#gen::<u8>(),
+	)
+}
+
+pub fn ip_addr_v6() -> std::net::Ipv6Addr {
+	let mut rng = thread_rng();
+	std::net::Ipv6Addr::new(
+		rng.r#gen::<u16>(),
+		rng.r#gen::<u16>(),
+		rng.r#gen::<u16>(),
+		rng.r#gen::<u16>(),
+		rng.r#gen::<u16>(),
+		rng.r#gen::<u16>(),
+		rng.r#gen::<u16>(),
+		rng.r#gen::<u16>(),
+	)
+}

package/packages/util/src/format.rs

@@ -0,0 +1,185 @@
+use std::{
+	fmt::{self, Display, Formatter},
+	iter::Iterator,
+};
+
+use lazy_static::lazy_static;
+use rand::seq::IteratorRandom;
+use regex::Regex;
+
+use crate::check;
+
+lazy_static! {
+	static ref SPACE_REPLACE: Regex = Regex::new(r#" +"#).unwrap();
+}
+
+/// Renders `Some<T>` as `T` and does not render `None`.
+pub struct OptDisplay<T: Display>(pub Option<T>);
+
+impl<T: Display> Display for OptDisplay<T> {
+	fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
+		if let Some(value) = &self.0 {
+			write!(f, "{}", value)
+		} else {
+			Ok(())
+		}
+	}
+}
+
+/// Formats a user's biography properly. Assumes util::check::biography succeeded before this function
+pub fn biography<T: AsRef<str>>(s: T) -> String {
+	let s = s.as_ref();
+
+	// Get chars (filtered to only have MAX_NEW_LINES new lines)
+	let mut accum = 0;
+	let chars = s
+		.chars()
+		.filter(|c| {
+			if c == &'\n' {
+				accum += 1;
+
+				accum <= check::MAX_NEW_LINES
+			} else {
+				true
+			}
+		})
+		.collect::<Vec<char>>();
+
+	if let Ok(string) = truncate_at_code_point(&chars, check::MAX_BIOGRAPHY_LEN) {
+		// Replace chains of spaces
+		SPACE_REPLACE.replace_all(&string, " ").into_owned()
+	} else {
+		"".to_owned()
+	}
+}
+
+pub fn truncate_at_code_point(
+	chars: &Vec<char>,
+	length: usize,
+) -> Result<String, std::string::FromUtf8Error> {
+	let mut accum = 0;
+
+	String::from_utf8(
+		chars
+			.iter()
+			.map(|c| Vec::from(c.encode_utf8(&mut [0u8; 8]).as_bytes()))
+			.filter(|c| {
+				accum += c.len();
+
+				accum < length + 1
+			})
+			.flatten()
+			.collect(),
+	)
+}
+
+pub fn item_list<'a, I: Iterator<Item = impl AsRef<str>>>(mut iter: I) -> String {
+	let mut s = String::new();
+
+	if let Some(item) = iter.next() {
+		s.push_str(item.as_ref());
+	}
+
+	for item in iter {
+		s.push_str(", ");
+		s.push_str(item.as_ref());
+	}
+
+	s
+}
+
+pub fn str_to_ident(s: impl AsRef<str>) -> String {
+	let s = s.as_ref().to_ascii_lowercase();
+	let mut last_was_underscore = false;
+
+	let dashed = s
+		.chars()
+		.filter_map(|c| match c {
+			'0'..='9' | 'a'..='z' => {
+				last_was_underscore = false;
+
+				Some(c)
+			}
+			_ => {
+				if !last_was_underscore {
+					last_was_underscore = true;
+					Some('-')
+				} else {
+					None
+				}
+			}
+		})
+		.collect::<String>();
+
+	dashed.trim_matches('-').to_string()
+}
+
+pub fn gen_name_id(s: impl AsRef<str>, default: &str) -> String {
+	assert!(
+		default.len() + 8 <= check::MAX_IDENT_LEN,
+		"default ident too long"
+	);
+
+	let proc_ident = str_to_ident(s);
+
+	// Default
+	let (proc_ident, rng_count) = if proc_ident.is_empty() {
+		(default, 8)
+	} else {
+		(proc_ident.as_str(), 3)
+	};
+
+	// Choose a random hash to add to the name id
+	let chars = "abcdefghijklmnopqrstuvwxyz1234567890"; // pragma: allowlist secret
+	let mut rng = rand::thread_rng();
+	let hash = std::iter::repeat_with(|| chars.chars().choose(&mut rng))
+		.flatten()
+		.take(rng_count);
+
+	proc_ident
+		.chars()
+		.take(check::MAX_IDENT_LEN - 4)
+		.chain(std::iter::once('-'))
+		.chain(hash)
+		.collect::<String>()
+}
+
+pub fn duration(ms: i64, relative: bool) -> String {
+	let neg = ms < 0;
+	let ms = ms.abs();
+	let mut parts = Vec::with_capacity(5);
+
+	if relative && neg {
+		parts.push("in".to_string());
+	}
+
+	if ms == 0 {
+		parts.push("0ms".to_string());
+	} else if ms < 1000 {
+		parts.push(format!("{ms}ms"));
+	} else {
+		let days = ms / 86_400_000;
+		let hours = (ms % 86_400_000) / 3_600_000;
+		let minutes = (ms % 3_600_000) / 60_000;
+		let seconds = (ms % 60_000) / 1_000;
+
+		if days > 0 {
+			parts.push(format!("{days}d"));
+		}
+		if hours > 0 {
+			parts.push(format!("{hours}h"));
+		}
+		if minutes > 0 {
+			parts.push(format!("{minutes}m"));
+		}
+		if ms < 60_000 && seconds > 0 {
+			parts.push(format!("{seconds}s"));
+		}
+	}
+
+	if relative && !neg {
+		parts.push("ago".to_string());
+	}
+
+	parts.join(" ")
+}

package/packages/util/src/future.rs

@@ -0,0 +1 @@
+pub use rivet_tracing_utils::*;

package/packages/util/src/geo.rs

@@ -0,0 +1,5 @@
+pub mod convert {
+	pub fn kilometers_to_miles(kilometers: f64) -> f64 {
+		kilometers * 0.621371
+	}
+}

package/packages/util/src/lib.rs

@@ -0,0 +1,40 @@
+pub use id::Id;
+pub use rivet_util_id as id;
+
+pub mod backoff;
+pub mod billing;
+pub mod build_meta;
+pub mod check;
+pub mod duration;
+pub mod faker;
+pub mod format;
+pub mod future;
+pub mod geo;
+pub mod math;
+pub mod req;
+pub mod serde;
+pub mod size;
+pub mod sort;
+pub mod timestamp;
+pub mod url;
+
+/// Slices a string without panicking on char boundaries. Defaults to the left side of the char if a slice
+// is invalid. Will still panic if start > end.
+pub fn safe_slice(s: &str, start: usize, end: usize) -> &str {
+	let mut new_start = 0;
+	let mut new_end = s.len();
+
+	for (i, _) in s.char_indices() {
+		if i <= start {
+			new_start = i;
+		}
+
+		if i >= end {
+			break;
+		}
+
+		new_end = i;
+	}
+
+	&s[new_start..=new_end]
+}

package/packages/util/src/math.rs

@@ -0,0 +1,35 @@
+/// Divide integers of any type, rounding up. Panics on dividing by 0.
+#[deprecated(note = "use x.div_ceil(y) instead")]
+#[macro_export]
+macro_rules! div_up {
+	($a:expr, $b:expr) => {
+		($a + ($b - 1)) / $b
+	};
+}
+
+/// Performs ceiling division for i64 values.
+///
+/// Returns the smallest integer greater than or equal to `a / b`.
+///
+/// # Examples
+/// ```
+/// assert_eq!(div_ceil_i64(10, 3), 4);  // 10/3 = 3.33.. -> 4
+/// assert_eq!(div_ceil_i64(9, 3), 3);   // 9/3 = 3 -> 3
+/// assert_eq!(div_ceil_i64(-10, 3), -3); // -10/3 = -3.33.. -> -3
+/// ```
+///
+/// # Panics
+/// Panics if `b` is zero.
+pub fn div_ceil_i64(a: i64, b: i64) -> i64 {
+	if b == 0 {
+		panic!("attempt to divide by zero");
+	}
+
+	if a == 0 || (a > 0 && b > 0) || (a < 0 && b < 0) {
+		// Standard ceiling division when signs match or a is zero
+		(a + b - 1) / b
+	} else {
+		// When signs differ, regular division gives the ceiling
+		a / b
+	}
+}

package/packages/util/src/req.rs

@@ -0,0 +1,41 @@
+use std::time::Duration;
+
+use anyhow::*;
+use async_trait::async_trait;
+
+#[async_trait]
+pub trait SendRetry {
+	/// Retries the request upon receiving a 429 response.
+	async fn send_retry(self, mut retries: usize) -> Result<reqwest::Response>;
+}
+
+#[async_trait]
+impl SendRetry for reqwest::RequestBuilder {
+	async fn send_retry(self, mut retries: usize) -> Result<reqwest::Response> {
+		loop {
+			let req = self.try_clone().context("failed cloning req")?;
+			let res = req.send().await?;
+
+			if let reqwest::StatusCode::TOO_MANY_REQUESTS = res.status() {
+				if retries != 0 {
+					retries -= 1;
+
+					// TODO: Parse all valid Retry-After formats. Currently only parses duration
+					let retry_time = res
+						.headers()
+						.get("Retry-After")
+						.map(|x| x.to_str())
+						.transpose()?
+						.map(|x| x.parse::<u64>())
+						.transpose()?
+						.unwrap_or(5);
+					tokio::time::sleep(Duration::from_secs(retry_time)).await;
+
+					continue;
+				}
+			}
+
+			break Ok(res);
+		}
+	}
+}