Type of Change

• Bugfix
• New feature
• Enhancement
• Refactoring
• Dependency updates
• Documentation
• CI/CD

Description

This PR updates the usages of the once_cell crate and its types with their standard library equivalents. This PR replaces:

• once_cell::sync::OnceCell with std::sync::OnceLock.
• once_cell::sync::Lazy with std::sync::LazyLock.

However, this is not a complete migration, since once_cell::sync::OnceCell::get_or_try_init() cannot be replaced with std::sync::OnceLock::get_or_try_init() as it is not available in the stable toolchain yet, as of Rust 1.86. Due to this reason, once_cell is still kept as a dependency in the common_utils, external_services and router crates, only where the get_or_try_init() method is being used.

P.S.: This code was mostly written by AI, which I've also reviewed along the way.

Motivation and Context

This PR just replaces usages of one of our dependencies to the standard library equivalents.

How did you test it?

1. Performed sanity testing via Postman. The expected result is that there are no behavior changes due to this PR.

2. I have run unit tests on the euclid and common_utils crates, all of them (from these two crates) passed. Some of these unit tests make use of the static variables that were migrated in this PR:

   • hyperswitch/crates/common_utils/src/validation.rs

     Lines 111 to 120 in 5fd6df7

     	fn test_validate_email() {
     	let result = validate_email("abc@example.com");
     	assert!(result.is_ok());
     	let result = validate_email("abc+123@example.com");
     	assert!(result.is_ok());
     	let result = validate_email("");
     	assert!(result.is_err());
     	}

     • This test exercises the EMAIL_REGEX static variable.

   • hyperswitch/crates/euclid/src/dssa/analyzer.rs

     Lines 258 to 377 in 5fd6df7

     	fn test_conflicting_assertion_detection() {
     	let program_str = r#"
     	default: ["stripe", "adyen"]
     	stripe_first: ["stripe", "adyen"]
     	{
     	payment_method = wallet {
     	amount > 500 & capture_method = automatic
     	amount < 500 & payment_method = card
     	}
     	}
     	"#;
     	let (_, program) = ast::parser::program::<DummyOutput>(program_str).expect("Program");
     	let analysis_result = analyze(program, None);
     	if let Err(types::AnalysisError {
     	error_type: types::AnalysisErrorType::ConflictingAssertions { key, values },
     	..
     	}) = analysis_result
     	{
     	assert!(
     	matches!(key.kind, dir::DirKeyKind::PaymentMethod),
     	"Key should be payment_method"
     	);
     	let values: Vec<dir::DirValue> = values.into_iter().map(|v| v.value).collect();
     	assert_eq!(values.len(), 2, "There should be 2 conflicting conditions");
     	assert!(
     	values.contains(&dirval!(PaymentMethod = Wallet)),
     	"Condition should include payment_method = wallet"
     	);
     	assert!(
     	values.contains(&dirval!(PaymentMethod = Card)),
     	"Condition should include payment_method = card"
     	);
     	} else {
     	panic!("Did not receive conflicting assertions error");
     	}
     	}
     	#[test]
     	fn test_exhaustive_negation_detection() {
     	let program_str = r#"
     	default: ["stripe"]
     	rule_1: ["adyen"]
     	{
     	payment_method /= wallet {
     	capture_method = manual & payment_method /= card {
     	authentication_type = three_ds & payment_method /= pay_later {
     	amount > 1000 & payment_method /= bank_redirect {
     	payment_method /= crypto
     	& payment_method /= bank_debit
     	& payment_method /= bank_transfer
     	& payment_method /= upi
     	& payment_method /= reward
     	& payment_method /= voucher
     	& payment_method /= gift_card
     	& payment_method /= card_redirect
     	& payment_method /= real_time_payment
     	}
     	}
     	}
     	}
     	}
     	"#;
     	let (_, program) = ast::parser::program::<DummyOutput>(program_str).expect("Program");
     	let analysis_result = analyze(program, None);
     	if let Err(types::AnalysisError {
     	error_type: types::AnalysisErrorType::ExhaustiveNegation { key, .. },
     	..
     	}) = analysis_result
     	{
     	assert!(
     	matches!(key.kind, dir::DirKeyKind::PaymentMethod),
     	"Expected key to be payment_method"
     	);
     	} else {
     	panic!("Expected exhaustive negation error");
     	}
     	}
     	#[test]
     	fn test_negated_assertions_detection() {
     	let program_str = r#"
     	default: ["stripe"]
     	rule_1: ["adyen"]
     	{
     	payment_method = wallet {
     	amount > 500 {
     	capture_method = automatic
     	}
     	amount < 501 {
     	payment_method /= wallet
     	}
     	}
     	}
     	"#;
     	let (_, program) = ast::parser::program::<DummyOutput>(program_str).expect("Program");
     	let analysis_result = analyze(program, None);
     	if let Err(types::AnalysisError {
     	error_type: types::AnalysisErrorType::NegatedAssertion { value, .. },
     	..
     	}) = analysis_result
     	{
     	assert_eq!(
     	value,
     	dirval!(PaymentMethod = Wallet),
     	"Expected to catch payment_method = wallet as conflict"
     	);
     	} else {
     	panic!("Expected negated assertion error");
     	}
     	}

     • These tests call analyze without providing a specific graph, thus using ANALYSIS_GRAPH.

   Screenshot of unit test run:

   

3. I have confirmed that cache system works correctly by adding a log line in case of in-memory cache hits (this log line was added only for testing and is not included in the PR). The in-memory caches also make use of static variables and LazyLock, so their correct functioning indicates that the migration hasn't broken the cache system.

   

Checklist

• I formatted the code cargo +nightly fmt --all
• I addressed lints thrown by cargo clippy
• I reviewed the submitted code
• I added unit tests for my changes where possible