@rivetkit/engine 1.0.0 → 2.2.1-pr.4600.b74ff3b

package/packages/clickhouse-user-query/src/schema.rs

@@ -1,78 +0,0 @@
-use crate::error::{Result, UserQueryError};
-use serde::{Deserialize, Serialize};
-
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct Schema {
-	pub properties: Vec<Property>,
-}
-
-impl Schema {
-	pub fn new(properties: Vec<Property>) -> Result<Self> {
-		// All property validation happens in Property::new()
-		Ok(Self { properties })
-	}
-
-	pub fn get_property(&self, name: &str) -> Option<&Property> {
-		self.properties.iter().find(|p| p.name == name)
-	}
-}
-
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct Property {
-	pub name: String,
-	pub is_map: bool,
-	/// The type of values in the property. For map properties, this is the type of the map values.
-	pub ty: PropertyType,
-	/// Whether this property can be used in GROUP BY clauses
-	pub can_group_by: bool,
-}
-
-impl Property {
-	pub fn new(name: String, is_map: bool, ty: PropertyType) -> Result<Self> {
-		validate_property_name(&name)?;
-		Ok(Self {
-			name,
-			is_map,
-			ty,
-			can_group_by: false,
-		})
-	}
-
-	pub fn with_group_by(mut self, can_group_by: bool) -> Self {
-		self.can_group_by = can_group_by;
-		self
-	}
-}
-
-#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
-pub enum PropertyType {
-	Bool,
-	String,
-	Number,
-}
-
-impl PropertyType {
-	pub fn type_name(&self) -> &'static str {
-		match self {
-			PropertyType::Bool => "bool",
-			PropertyType::String => "string",
-			PropertyType::Number => "number",
-		}
-	}
-}
-
-fn validate_property_name(name: &str) -> Result<()> {
-	if name.is_empty() {
-		return Err(UserQueryError::InvalidPropertyName(name.to_string()));
-	}
-
-	if !name.chars().all(|c| c.is_alphanumeric() || c == '_') {
-		return Err(UserQueryError::InvalidPropertyName(name.to_string()));
-	}
-
-	if name.chars().next().unwrap().is_numeric() {
-		return Err(UserQueryError::InvalidPropertyName(name.to_string()));
-	}
-
-	Ok(())
-}

package/packages/clickhouse-user-query/tests/builder_tests.rs

@@ -1,619 +0,0 @@
-use clickhouse_user_query::*;
-
-fn create_test_schema() -> Schema {
-	Schema::new(vec![
-		Property::new("prop_a".to_string(), false, PropertyType::String)
-			.unwrap()
-			.with_group_by(false),
-		Property::new("prop_b".to_string(), true, PropertyType::String)
-			.unwrap()
-			.with_group_by(false),
-		Property::new("bool_prop".to_string(), false, PropertyType::Bool)
-			.unwrap()
-			.with_group_by(false),
-		Property::new("number_prop".to_string(), false, PropertyType::Number)
-			.unwrap()
-			.with_group_by(false),
-	])
-	.unwrap()
-}
-
-#[test]
-fn test_simple_string_equal() {
-	let schema = create_test_schema();
-	let query = QueryExpr::StringEqual {
-		property: "prop_a".to_string(),
-		map_key: None,
-		value: "foo".to_string(),
-		case_insensitive: false,
-	};
-
-	let builder = UserDefinedQueryBuilder::new(&schema, Some(&query)).unwrap();
-	assert_eq!(builder.where_expr(), "prop_a = ?");
-}
-
-#[test]
-fn test_map_key_access() {
-	let schema = create_test_schema();
-	let query = QueryExpr::StringEqual {
-		property: "prop_b".to_string(),
-		map_key: Some("sub".to_string()),
-		value: "bar".to_string(),
-		case_insensitive: false,
-	};
-
-	let builder = UserDefinedQueryBuilder::new(&schema, Some(&query)).unwrap();
-	assert_eq!(builder.where_expr(), "prop_b['sub'] = ?");
-}
-
-#[test]
-fn test_and_query() {
-	let schema = create_test_schema();
-	let query = QueryExpr::And {
-		exprs: vec![
-			QueryExpr::StringEqual {
-				property: "prop_a".to_string(),
-				map_key: None,
-				value: "foo".to_string(),
-				case_insensitive: false,
-			},
-			QueryExpr::BoolEqual {
-				property: "bool_prop".to_string(),
-				map_key: None,
-				value: true,
-			},
-		],
-	};
-
-	let builder = UserDefinedQueryBuilder::new(&schema, Some(&query)).unwrap();
-	assert_eq!(builder.where_expr(), "(prop_a = ? AND bool_prop = ?)");
-}
-
-#[test]
-fn test_property_not_found() {
-	let schema = create_test_schema();
-	let query = QueryExpr::StringEqual {
-		property: "nonexistent".to_string(),
-		map_key: None,
-		value: "foo".to_string(),
-		case_insensitive: false,
-	};
-
-	let result = UserDefinedQueryBuilder::new(&schema, Some(&query));
-	assert!(matches!(result, Err(UserQueryError::PropertyNotFound(_))));
-}
-
-#[test]
-fn test_type_mismatch() {
-	let schema = create_test_schema();
-	let query = QueryExpr::BoolEqual {
-		property: "prop_a".to_string(), // This is a string property
-		map_key: None,
-		value: true,
-	};
-
-	let result = UserDefinedQueryBuilder::new(&schema, Some(&query));
-	assert!(matches!(
-		result,
-		Err(UserQueryError::PropertyTypeMismatch(_, _, _))
-	));
-}
-
-#[test]
-fn test_map_keys_not_supported() {
-	let schema = create_test_schema();
-	let query = QueryExpr::StringEqual {
-		property: "prop_a".to_string(), // This doesn't support map keys
-		map_key: Some("sub".to_string()),
-		value: "foo".to_string(),
-		case_insensitive: false,
-	};
-
-	let result = UserDefinedQueryBuilder::new(&schema, Some(&query));
-	assert!(matches!(
-		result,
-		Err(UserQueryError::MapKeysNotSupported(_))
-	));
-}
-
-#[test]
-fn test_invalid_property_name() {
-	let schema = create_test_schema();
-	let query = QueryExpr::StringEqual {
-		property: "prop-with-dashes".to_string(),
-		map_key: None,
-		value: "foo".to_string(),
-		case_insensitive: false,
-	};
-
-	// Invalid property names are now caught as "not found" since schema validation
-	// happens at schema creation time, not query time
-	let builder_result = UserDefinedQueryBuilder::new(&schema, Some(&query));
-	assert!(matches!(
-		builder_result,
-		Err(UserQueryError::PropertyNotFound(_))
-	));
-}
-
-#[test]
-fn test_map_key_with_safe_chars() {
-	let schema = create_test_schema();
-	let query = QueryExpr::StringEqual {
-		property: "prop_b".to_string(), // This supports map keys
-		map_key: Some("sub_with_underscores123".to_string()),
-		value: "foo".to_string(),
-		case_insensitive: false,
-	};
-
-	// Map keys with safe characters (alphanumeric + underscore) should work
-	let builder_result = UserDefinedQueryBuilder::new(&schema, Some(&query));
-	assert!(builder_result.is_ok());
-
-	let builder = builder_result.unwrap();
-	assert_eq!(
-		builder.where_expr(),
-		"prop_b['sub_with_underscores123'] = ?"
-	);
-}
-
-#[test]
-fn test_number_greater() {
-	let schema = create_test_schema();
-	let query = QueryExpr::NumberGreater {
-		property: "number_prop".to_string(),
-		map_key: None,
-		value: 42.5,
-	};
-
-	let builder = UserDefinedQueryBuilder::new(&schema, Some(&query)).unwrap();
-	assert_eq!(builder.where_expr(), "number_prop > ?");
-}
-
-#[test]
-fn test_number_less_or_equal() {
-	let schema = create_test_schema();
-	let query = QueryExpr::NumberLessOrEqual {
-		property: "number_prop".to_string(),
-		map_key: None,
-		value: 100.0,
-	};
-
-	let builder = UserDefinedQueryBuilder::new(&schema, Some(&query)).unwrap();
-	assert_eq!(builder.where_expr(), "number_prop <= ?");
-}
-
-#[test]
-fn test_number_with_map_key() {
-	let schema = Schema::new(vec![
-		Property::new("metrics".to_string(), true, PropertyType::Number)
-			.unwrap()
-			.with_group_by(false),
-	])
-	.unwrap();
-
-	let query = QueryExpr::NumberEqual {
-		property: "metrics".to_string(),
-		map_key: Some("score".to_string()),
-		value: 95.5,
-	};
-
-	let builder = UserDefinedQueryBuilder::new(&schema, Some(&query)).unwrap();
-	assert_eq!(builder.where_expr(), "metrics['score'] = ?");
-}
-
-#[test]
-fn test_number_type_mismatch() {
-	let schema = create_test_schema();
-	let query = QueryExpr::NumberGreater {
-		property: "prop_a".to_string(), // This is a String type, not Number
-		map_key: None,
-		value: 42.0,
-	};
-
-	let result = UserDefinedQueryBuilder::new(&schema, Some(&query));
-	assert!(matches!(
-		result,
-		Err(UserQueryError::PropertyTypeMismatch(_, _, _))
-	));
-}
-
-#[test]
-fn test_map_key_validation_valid_names() {
-	let schema = create_test_schema();
-
-	// Valid map key names
-	let valid_names = vec![
-		"valid_name",
-		"valid123",
-		"name_with_underscore",
-		"CamelCase",
-		"a",
-		"a1",
-		"test_case_123",
-	];
-
-	for name in valid_names {
-		let query = QueryExpr::StringEqual {
-			property: "prop_b".to_string(),
-			map_key: Some(name.to_string()),
-			value: "test".to_string(),
-			case_insensitive: false,
-		};
-
-		let result = UserDefinedQueryBuilder::new(&schema, Some(&query));
-		assert!(
-			result.is_ok(),
-			"Valid map key name '{}' should be accepted",
-			name
-		);
-	}
-}
-
-#[test]
-fn test_map_key_validation_invalid_names() {
-	let schema = create_test_schema();
-
-	// Invalid map key names
-	let long_name = "a".repeat(65);
-	let invalid_names = vec![
-		"",              // Empty
-		"123invalid",    // Starts with number
-		"invalid-name",  // Contains dash
-		"invalid.name",  // Contains dot
-		"invalid name",  // Contains space
-		"invalid@name",  // Contains special character
-		"invalid'name",  // Contains quote
-		"invalid\"name", // Contains double quote
-		"invalid;name",  // Contains semicolon
-		"invalid(name",  // Contains parenthesis
-		"invalid)name",  // Contains parenthesis
-		"invalid[name",  // Contains bracket
-		"invalid]name",  // Contains bracket
-		"invalid{name",  // Contains brace
-		"invalid}name",  // Contains brace
-		"invalid+name",  // Contains plus
-		"invalid=name",  // Contains equals
-		"invalid*name",  // Contains asterisk
-		"invalid%name",  // Contains percent
-		"invalid$name",  // Contains dollar
-		"invalid#name",  // Contains hash
-		"invalid!name",  // Contains exclamation
-		"invalid|name",  // Contains pipe
-		"invalid\\name", // Contains backslash
-		"invalid/name",  // Contains forward slash
-		"invalid<name",  // Contains less than
-		"invalid>name",  // Contains greater than
-		"invalid?name",  // Contains question mark
-		"invalid~name",  // Contains tilde
-		"invalid`name",  // Contains backtick
-		&long_name,      // Too long (over 64 characters)
-	];
-
-	for name in invalid_names {
-		let query = QueryExpr::StringEqual {
-			property: "prop_b".to_string(),
-			map_key: Some(name.to_string()),
-			value: "test".to_string(),
-			case_insensitive: false,
-		};
-
-		let result = UserDefinedQueryBuilder::new(&schema, Some(&query));
-		assert!(
-			result.is_err(),
-			"Invalid map key name '{}' should be rejected",
-			name
-		);
-		assert!(
-			matches!(result, Err(UserQueryError::InvalidMapKeyName(_))),
-			"Invalid map key name '{}' should return InvalidMapKeyName error",
-			name
-		);
-	}
-}
-
-#[test]
-fn test_map_key_validation_sql_injection_attempts() {
-	let schema = create_test_schema();
-
-	// SQL injection attempts
-	let injection_attempts = vec![
-		"'; DROP TABLE users; --",
-		"' OR '1'='1",
-		"'; INSERT INTO users VALUES ('hacker'); --",
-		"' UNION SELECT * FROM passwords --",
-		"'; DELETE FROM users; --",
-		"'/**/OR/**/1=1",
-		"' OR 1=1 #",
-		"admin'--",
-		"' OR 'x'='x",
-		"1' OR '1'='1",
-		"'; EXEC xp_cmdshell('dir'); --",
-		"'; SHUTDOWN; --",
-	];
-
-	for attempt in injection_attempts {
-		let query = QueryExpr::StringEqual {
-			property: "prop_b".to_string(),
-			map_key: Some(attempt.to_string()),
-			value: "test".to_string(),
-			case_insensitive: false,
-		};
-
-		let result = UserDefinedQueryBuilder::new(&schema, Some(&query));
-		assert!(
-			result.is_err(),
-			"SQL injection attempt '{}' should be rejected",
-			attempt
-		);
-		assert!(
-			matches!(result, Err(UserQueryError::InvalidMapKeyName(_))),
-			"SQL injection attempt '{}' should return InvalidMapKeyName error",
-			attempt
-		);
-	}
-}
-
-#[test]
-fn test_string_in() {
-	let schema = create_test_schema();
-	let query = QueryExpr::StringIn {
-		property: "prop_a".to_string(),
-		map_key: None,
-		values: vec!["foo".to_string(), "bar".to_string()],
-		case_insensitive: false,
-	};
-
-	let builder = UserDefinedQueryBuilder::new(&schema, Some(&query)).unwrap();
-	assert_eq!(builder.where_expr(), "prop_a IN (?, ?)");
-}
-
-#[test]
-fn test_string_not_in() {
-	let schema = create_test_schema();
-	let query = QueryExpr::StringNotIn {
-		property: "prop_a".to_string(),
-		map_key: None,
-		values: vec!["foo".to_string(), "bar".to_string()],
-		case_insensitive: false,
-	};
-
-	let builder = UserDefinedQueryBuilder::new(&schema, Some(&query)).unwrap();
-	assert_eq!(builder.where_expr(), "prop_a NOT IN (?, ?)");
-}
-
-#[test]
-fn test_number_in() {
-	let schema = create_test_schema();
-	let query = QueryExpr::NumberIn {
-		property: "number_prop".to_string(),
-		map_key: None,
-		values: vec![42.0, 84.0, 168.0],
-	};
-
-	let builder = UserDefinedQueryBuilder::new(&schema, Some(&query)).unwrap();
-	assert_eq!(builder.where_expr(), "number_prop IN (?, ?, ?)");
-}
-
-#[test]
-fn test_number_not_in() {
-	let schema = create_test_schema();
-	let query = QueryExpr::NumberNotIn {
-		property: "number_prop".to_string(),
-		map_key: None,
-		values: vec![1.0, 2.0],
-	};
-
-	let builder = UserDefinedQueryBuilder::new(&schema, Some(&query)).unwrap();
-	assert_eq!(builder.where_expr(), "number_prop NOT IN (?, ?)");
-}
-
-#[test]
-fn test_string_in_with_map_key() {
-	let schema = Schema::new(vec![
-		Property::new("metadata".to_string(), true, PropertyType::String)
-			.unwrap()
-			.with_group_by(false),
-	])
-	.unwrap();
-
-	let query = QueryExpr::StringIn {
-		property: "metadata".to_string(),
-		map_key: Some("category".to_string()),
-		values: vec!["premium".to_string(), "basic".to_string()],
-		case_insensitive: false,
-	};
-
-	let builder = UserDefinedQueryBuilder::new(&schema, Some(&query)).unwrap();
-	assert_eq!(builder.where_expr(), "metadata['category'] IN (?, ?)");
-}
-
-#[test]
-fn test_empty_in_values() {
-	let schema = create_test_schema();
-	let query = QueryExpr::StringIn {
-		property: "prop_a".to_string(),
-		map_key: None,
-		values: vec![],
-		case_insensitive: false,
-	};
-
-	let result = UserDefinedQueryBuilder::new(&schema, Some(&query));
-	assert!(matches!(result, Err(UserQueryError::EmptyArrayValues(_))));
-}
-
-#[test]
-fn test_group_by_simple() {
-	let schema = Schema::new(vec![
-		Property::new("user_id".to_string(), false, PropertyType::String)
-			.unwrap()
-			.with_group_by(true),
-		Property::new("status".to_string(), false, PropertyType::String)
-			.unwrap()
-			.with_group_by(true),
-		Property::new("score".to_string(), false, PropertyType::Number)
-			.unwrap()
-			.with_group_by(false),
-	])
-	.unwrap();
-
-	let query = QueryExpr::StringEqual {
-		property: "status".to_string(),
-		map_key: None,
-		value: "active".to_string(),
-		case_insensitive: false,
-	};
-
-	let key_path = KeyPath::new("user_id".to_string());
-	let builder =
-		UserDefinedQueryBuilder::new_with_group_by(&schema, Some(&query), Some(&key_path)).unwrap();
-	assert_eq!(builder.where_expr(), "status = ?");
-	assert_eq!(builder.group_by_expr(), Some("user_id"));
-}
-
-#[test]
-fn test_group_by_multiple_columns() {
-	let schema = Schema::new(vec![
-		Property::new("user_id".to_string(), false, PropertyType::String)
-			.unwrap()
-			.with_group_by(true),
-		Property::new("status".to_string(), false, PropertyType::String)
-			.unwrap()
-			.with_group_by(true),
-		Property::new("region".to_string(), false, PropertyType::String)
-			.unwrap()
-			.with_group_by(true),
-	])
-	.unwrap();
-
-	let query = QueryExpr::StringEqual {
-		property: "status".to_string(),
-		map_key: None,
-		value: "active".to_string(),
-		case_insensitive: false,
-	};
-
-	// Note: new_with_group_by only supports a single group by column
-	let key_path = KeyPath::new("user_id".to_string());
-	let builder =
-		UserDefinedQueryBuilder::new_with_group_by(&schema, Some(&query), Some(&key_path)).unwrap();
-	assert_eq!(builder.group_by_expr(), Some("user_id"));
-}
-
-#[test]
-fn test_group_by_property_not_groupable() {
-	let schema = Schema::new(vec![
-		Property::new("user_id".to_string(), false, PropertyType::String)
-			.unwrap()
-			.with_group_by(true),
-		Property::new("score".to_string(), false, PropertyType::Number)
-			.unwrap()
-			.with_group_by(false),
-	])
-	.unwrap();
-
-	let query = QueryExpr::NumberGreater {
-		property: "score".to_string(),
-		map_key: None,
-		value: 50.0,
-	};
-
-	let key_path = KeyPath::new("score".to_string());
-	let result = UserDefinedQueryBuilder::new_with_group_by(&schema, Some(&query), Some(&key_path));
-	assert!(matches!(
-		result,
-		Err(UserQueryError::PropertyCannotBeGroupedBy(_))
-	));
-}
-
-#[test]
-fn test_group_by_map_property_rejected() {
-	let schema = Schema::new(vec![
-		Property::new("user_id".to_string(), false, PropertyType::String)
-			.unwrap()
-			.with_group_by(true),
-		Property::new("metadata".to_string(), true, PropertyType::String)
-			.unwrap()
-			.with_group_by(true),
-	])
-	.unwrap();
-
-	let query = QueryExpr::StringEqual {
-		property: "user_id".to_string(),
-		map_key: None,
-		value: "user123".to_string(),
-		case_insensitive: false,
-	};
-
-	let key_path = KeyPath::new("metadata".to_string());
-	let result = UserDefinedQueryBuilder::new_with_group_by(&schema, Some(&query), Some(&key_path));
-	assert!(matches!(
-		result,
-		Err(UserQueryError::MapPropertyCannotBeGroupedBy(_))
-	));
-}
-
-#[test]
-fn test_group_by_property_not_found() {
-	let schema = Schema::new(vec![
-		Property::new("user_id".to_string(), false, PropertyType::String)
-			.unwrap()
-			.with_group_by(true),
-	])
-	.unwrap();
-
-	let query = QueryExpr::StringEqual {
-		property: "user_id".to_string(),
-		map_key: None,
-		value: "user123".to_string(),
-		case_insensitive: false,
-	};
-
-	let key_path = KeyPath::new("unknown_column".to_string());
-	let result = UserDefinedQueryBuilder::new_with_group_by(&schema, Some(&query), Some(&key_path));
-	assert!(matches!(result, Err(UserQueryError::PropertyNotFound(_))));
-}
-
-#[test]
-fn test_group_by_empty_allowed() {
-	let schema = Schema::new(vec![
-		Property::new("user_id".to_string(), false, PropertyType::String)
-			.unwrap()
-			.with_group_by(true),
-	])
-	.unwrap();
-
-	let query = QueryExpr::StringEqual {
-		property: "user_id".to_string(),
-		map_key: None,
-		value: "user123".to_string(),
-		case_insensitive: false,
-	};
-
-	let builder = UserDefinedQueryBuilder::new_with_group_by(&schema, Some(&query), None).unwrap();
-	assert_eq!(builder.group_by_expr(), None);
-}
-
-#[test]
-fn test_none_expr_returns_true() {
-	// Create schema with groupable property
-	let schema = Schema::new(vec![
-		Property::new("prop_a".to_string(), false, PropertyType::String)
-			.unwrap()
-			.with_group_by(true),
-		Property::new("prop_b".to_string(), false, PropertyType::Number)
-			.unwrap()
-			.with_group_by(false),
-	])
-	.unwrap();
-
-	// Test with None expression
-	let builder = UserDefinedQueryBuilder::new(&schema, None).unwrap();
-	assert_eq!(builder.where_expr(), "true");
-
-	// Test with None expression and group by
-	let key_path = KeyPath::new("prop_a".to_string());
-	let builder_with_group =
-		UserDefinedQueryBuilder::new_with_group_by(&schema, None, Some(&key_path)).unwrap();
-	assert_eq!(builder_with_group.where_expr(), "true");
-	assert_eq!(builder_with_group.group_by_expr(), Some("prop_a"));
-}