1use std::time::{SystemTime, UNIX_EPOCH};
2use uuid::Uuid;
3
4pub struct RewriteResult {
6 pub query: String,
8 pub generated_params: Vec<(String, serde_json::Value)>,
11}
12
13pub fn rewrite_query(query: &str) -> RewriteResult {
23 let bytes = query.as_bytes();
24 let len = bytes.len();
25 let mut output = Vec::with_capacity(len);
26 let mut generated_params = Vec::new();
27 let mut counters = [0u32; 3]; let mut i = 0;
29 let mut in_single_quote = false;
30 let mut in_double_quote = false;
31
32 while i < len {
33 if in_single_quote {
34 output.push(bytes[i]);
35 if bytes[i] == b'\'' {
36 if i + 1 < len && bytes[i + 1] == b'\'' {
38 output.push(bytes[i + 1]);
39 i += 2;
40 } else {
41 in_single_quote = false;
42 i += 1;
43 }
44 } else {
45 i += 1;
46 }
47 } else if in_double_quote {
48 output.push(bytes[i]);
49 if bytes[i] == b'"' {
50 in_double_quote = false;
51 }
52 i += 1;
53 } else if bytes[i] == b'\'' {
54 in_single_quote = true;
55 output.push(bytes[i]);
56 i += 1;
57 } else if bytes[i] == b'"' {
58 in_double_quote = true;
59 output.push(bytes[i]);
60 i += 1;
61 } else if let Some((func_idx, consumed)) = try_match_func(bytes, i) {
62 let (param_ref, param_name, param_value) = match func_idx {
63 0 => {
64 let n = counters[0];
65 counters[0] += 1;
66 (format!("$__graphd_uuid_{n}"), format!("__graphd_uuid_{n}"), Uuid::new_v4().to_string())
67 }
68 1 => {
69 let n = counters[1];
70 counters[1] += 1;
71 (format!("$__graphd_now_{n}"), format!("__graphd_now_{n}"), generate_timestamp())
72 }
73 _ => {
74 let n = counters[2];
75 counters[2] += 1;
76 (format!("$__graphd_date_{n}"), format!("__graphd_date_{n}"), generate_date())
77 }
78 };
79 output.extend_from_slice(param_ref.as_bytes());
80 generated_params.push((param_name, serde_json::Value::String(param_value)));
81 i += consumed;
82 } else {
83 output.push(bytes[i]);
84 i += 1;
85 }
86 }
87
88 let query_str = unsafe { String::from_utf8_unchecked(output) };
89 let query_str = rewrite_remove(&query_str);
90
91 RewriteResult {
92 query: query_str,
93 generated_params,
94 }
95}
96
97pub fn merge_params(
100 user_params: Option<&serde_json::Value>,
101 generated: &[(String, serde_json::Value)],
102) -> Option<serde_json::Value> {
103 if generated.is_empty() {
104 return user_params.cloned();
105 }
106 let mut obj = match user_params.and_then(|p| p.as_object()) {
107 Some(o) => o.clone(),
108 None => serde_json::Map::new(),
109 };
110 for (key, val) in generated {
111 obj.insert(key.clone(), val.clone());
112 }
113 Some(serde_json::Value::Object(obj))
114}
115
116const REMOVE_KW: &[u8] = b"REMOVE";
119
120fn rewrite_remove(query: &str) -> String {
126 let bytes = query.as_bytes();
127 let len = bytes.len();
128 let mut output = Vec::with_capacity(len);
129 let mut i = 0;
130 let mut in_single_quote = false;
131 let mut in_double_quote = false;
132 let mut changed = false;
133
134 while i < len {
135 if in_single_quote {
137 output.push(bytes[i]);
138 if bytes[i] == b'\'' {
139 if i + 1 < len && bytes[i + 1] == b'\'' {
140 output.push(bytes[i + 1]);
141 i += 2;
142 } else {
143 in_single_quote = false;
144 i += 1;
145 }
146 } else {
147 i += 1;
148 }
149 continue;
150 }
151 if in_double_quote {
152 output.push(bytes[i]);
153 if bytes[i] == b'"' {
154 in_double_quote = false;
155 }
156 i += 1;
157 continue;
158 }
159 if bytes[i] == b'\'' {
160 in_single_quote = true;
161 output.push(bytes[i]);
162 i += 1;
163 continue;
164 }
165 if bytes[i] == b'"' {
166 in_double_quote = true;
167 output.push(bytes[i]);
168 i += 1;
169 continue;
170 }
171
172 if i + REMOVE_KW.len() <= len
174 && bytes[i..i + REMOVE_KW.len()].eq_ignore_ascii_case(REMOVE_KW)
175 {
176 let before_ok = i == 0 || !bytes[i - 1].is_ascii_alphanumeric();
178 let after_pos = i + REMOVE_KW.len();
180 let after_ok =
181 after_pos >= len || !bytes[after_pos].is_ascii_alphanumeric();
182
183 if before_ok && after_ok {
184 let mut j = after_pos;
187 while j < len && bytes[j].is_ascii_whitespace() {
188 j += 1;
189 }
190
191 if let Some((prop_end, has_dot)) = scan_property_expr(bytes, j) {
192 if has_dot {
193 output.extend_from_slice(b"SET ");
195 output.extend_from_slice(&bytes[j..prop_end]);
197 output.extend_from_slice(b" = NULL");
198 i = prop_end;
199 changed = true;
200 continue;
201 }
202 }
203 }
204 }
205
206 output.push(bytes[i]);
207 i += 1;
208 }
209
210 if changed {
211 unsafe { String::from_utf8_unchecked(output) }
212 } else {
213 query.to_string()
214 }
215}
216
217fn scan_property_expr(bytes: &[u8], pos: usize) -> Option<(usize, bool)> {
223 let len = bytes.len();
224 if pos >= len {
225 return None;
226 }
227
228 let mut i = scan_identifier(bytes, pos)?;
230
231 if i >= len || bytes[i] != b'.' {
233 return Some((i, false));
234 }
235 i += 1; let end = scan_identifier(bytes, i)?;
239 Some((end, true))
240}
241
242fn scan_identifier(bytes: &[u8], pos: usize) -> Option<usize> {
245 let len = bytes.len();
246 if pos >= len {
247 return None;
248 }
249 if bytes[pos] == b'`' {
250 let mut i = pos + 1;
252 while i < len && bytes[i] != b'`' {
253 i += 1;
254 }
255 if i >= len {
256 return None; }
258 Some(i + 1) } else if bytes[pos].is_ascii_alphabetic() || bytes[pos] == b'_' {
260 let mut i = pos + 1;
261 while i < len && (bytes[i].is_ascii_alphanumeric() || bytes[i] == b'_') {
262 i += 1;
263 }
264 Some(i)
265 } else {
266 None
267 }
268}
269
270const FUNC_NAMES: &[&[u8]] = &[
275 b"gen_random_uuid", b"current_timestamp", b"current_date", ];
279
280fn try_match_func(bytes: &[u8], pos: usize) -> Option<(usize, usize)> {
283 for (idx, func_name) in FUNC_NAMES.iter().enumerate() {
284 let name_len = func_name.len();
285 if pos + name_len > bytes.len() {
286 continue;
287 }
288 if !bytes[pos..pos + name_len].eq_ignore_ascii_case(func_name) {
289 continue;
290 }
291 let mut j = pos + name_len;
293 while j < bytes.len() && bytes[j].is_ascii_whitespace() {
294 j += 1;
295 }
296 if j >= bytes.len() || bytes[j] != b'(' {
298 continue;
299 }
300 j += 1;
301 while j < bytes.len() && bytes[j].is_ascii_whitespace() {
303 j += 1;
304 }
305 if j < bytes.len() && bytes[j] == b')' {
307 return Some((idx, j + 1 - pos));
308 }
309 }
310 None
311}
312
313fn generate_timestamp() -> String {
316 let dur = SystemTime::now().duration_since(UNIX_EPOCH).unwrap();
317 let total_secs = dur.as_secs();
318 let micros = dur.subsec_micros();
319 let days = (total_secs / 86400) as i64;
320 let day_secs = total_secs % 86400;
321 let h = day_secs / 3600;
322 let m = (day_secs % 3600) / 60;
323 let s = day_secs % 60;
324 let (y, mo, d) = days_to_ymd(days);
325 format!("{y:04}-{mo:02}-{d:02}T{h:02}:{m:02}:{s:02}.{micros:06}")
326}
327
328fn generate_date() -> String {
331 let dur = SystemTime::now().duration_since(UNIX_EPOCH).unwrap();
332 let days = (dur.as_secs() / 86400) as i64;
333 let (y, m, d) = days_to_ymd(days);
334 format!("{y:04}-{m:02}-{d:02}")
335}
336
337fn days_to_ymd(days: i64) -> (i32, u32, u32) {
340 let z = days + 719468;
341 let era = (if z >= 0 { z } else { z - 146096 }) / 146097;
342 let doe = (z - era * 146097) as u32;
343 let yoe = (doe - doe / 1460 + doe / 36524 - doe / 146096) / 365;
344 let y = yoe as i64 + era * 400;
345 let doy = doe - (365 * yoe + yoe / 4 - yoe / 100);
346 let mp = (5 * doy + 2) / 153;
347 let d = doy - (153 * mp + 2) / 5 + 1;
348 let m = if mp < 10 { mp + 3 } else { mp - 9 };
349 let y = if m <= 2 { y + 1 } else { y };
350 (y as i32, m, d)
351}
352
353#[cfg(test)]
354mod tests {
355 use super::*;
356
357 #[test]
358 fn test_no_rewrite_plain_query() {
359 let r = rewrite_query("MATCH (n:Person) RETURN n.name");
360 assert_eq!(r.query, "MATCH (n:Person) RETURN n.name");
361 assert!(r.generated_params.is_empty());
362 }
363
364 #[test]
365 fn test_no_rewrite_return_literal() {
366 let r = rewrite_query("RETURN 42 AS x");
367 assert_eq!(r.query, "RETURN 42 AS x");
368 assert!(r.generated_params.is_empty());
369 }
370
371 #[test]
372 fn test_rewrite_gen_random_uuid() {
373 let r = rewrite_query("CREATE (:T {id: gen_random_uuid()})");
374 assert_eq!(r.query, "CREATE (:T {id: $__graphd_uuid_0})");
375 assert_eq!(r.generated_params.len(), 1);
376 assert_eq!(r.generated_params[0].0, "__graphd_uuid_0");
377 let val = r.generated_params[0].1.as_str().unwrap();
379 assert!(uuid::Uuid::parse_str(val).is_ok(), "Not a valid UUID: {val}");
380 }
381
382 #[test]
383 fn test_rewrite_current_timestamp() {
384 let r = rewrite_query("RETURN current_timestamp() AS ts");
385 assert_eq!(r.query, "RETURN $__graphd_now_0 AS ts");
386 assert_eq!(r.generated_params.len(), 1);
387 assert_eq!(r.generated_params[0].0, "__graphd_now_0");
388 let val = r.generated_params[0].1.as_str().unwrap();
389 assert!(val.len() >= 26, "Timestamp too short: {val}");
391 assert_eq!(&val[4..5], "-");
392 assert_eq!(&val[7..8], "-");
393 assert_eq!(&val[10..11], "T");
394 assert_eq!(&val[13..14], ":");
395 assert_eq!(&val[16..17], ":");
396 assert_eq!(&val[19..20], ".");
397 }
398
399 #[test]
400 fn test_rewrite_current_date() {
401 let r = rewrite_query("RETURN current_date() AS d");
402 assert_eq!(r.query, "RETURN $__graphd_date_0 AS d");
403 assert_eq!(r.generated_params.len(), 1);
404 assert_eq!(r.generated_params[0].0, "__graphd_date_0");
405 let val = r.generated_params[0].1.as_str().unwrap();
406 assert_eq!(val.len(), 10, "Date wrong length: {val}");
408 assert_eq!(&val[4..5], "-");
409 assert_eq!(&val[7..8], "-");
410 }
411
412 #[test]
413 fn test_rewrite_multiple_same_function() {
414 let r = rewrite_query("CREATE (:T {a: gen_random_uuid(), b: gen_random_uuid()})");
415 assert_eq!(r.query, "CREATE (:T {a: $__graphd_uuid_0, b: $__graphd_uuid_1})");
416 assert_eq!(r.generated_params.len(), 2);
417 assert_eq!(r.generated_params[0].0, "__graphd_uuid_0");
418 assert_eq!(r.generated_params[1].0, "__graphd_uuid_1");
419 assert_ne!(r.generated_params[0].1, r.generated_params[1].1);
421 }
422
423 #[test]
424 fn test_rewrite_mixed_functions() {
425 let r = rewrite_query(
426 "CREATE (:T {id: gen_random_uuid(), ts: current_timestamp(), d: current_date()})",
427 );
428 assert_eq!(
429 r.query,
430 "CREATE (:T {id: $__graphd_uuid_0, ts: $__graphd_now_0, d: $__graphd_date_0})"
431 );
432 assert_eq!(r.generated_params.len(), 3);
433 assert_eq!(r.generated_params[0].0, "__graphd_uuid_0");
434 assert_eq!(r.generated_params[1].0, "__graphd_now_0");
435 assert_eq!(r.generated_params[2].0, "__graphd_date_0");
436 }
437
438 #[test]
439 fn test_no_rewrite_in_single_quotes() {
440 let r = rewrite_query("RETURN 'gen_random_uuid()' AS s");
441 assert_eq!(r.query, "RETURN 'gen_random_uuid()' AS s");
442 assert!(r.generated_params.is_empty());
443 }
444
445 #[test]
446 fn test_no_rewrite_in_double_quotes() {
447 let r = rewrite_query("RETURN \"gen_random_uuid()\" AS s");
448 assert_eq!(r.query, "RETURN \"gen_random_uuid()\" AS s");
449 assert!(r.generated_params.is_empty());
450 }
451
452 #[test]
453 fn test_escaped_single_quotes() {
454 let r = rewrite_query("RETURN 'it''s gen_random_uuid()' AS s");
456 assert_eq!(r.query, "RETURN 'it''s gen_random_uuid()' AS s");
457 assert!(r.generated_params.is_empty());
458 }
459
460 #[test]
461 fn test_case_insensitive() {
462 let r1 = rewrite_query("RETURN GEN_RANDOM_UUID()");
463 assert_eq!(r1.query, "RETURN $__graphd_uuid_0");
464 assert_eq!(r1.generated_params.len(), 1);
465
466 let r2 = rewrite_query("RETURN Gen_Random_Uuid()");
467 assert_eq!(r2.query, "RETURN $__graphd_uuid_0");
468 assert_eq!(r2.generated_params.len(), 1);
469
470 let r3 = rewrite_query("RETURN CURRENT_TIMESTAMP()");
471 assert_eq!(r3.query, "RETURN $__graphd_now_0");
472
473 let r4 = rewrite_query("RETURN CURRENT_DATE()");
474 assert_eq!(r4.query, "RETURN $__graphd_date_0");
475 }
476
477 #[test]
478 fn test_whitespace_between_name_and_parens() {
479 let r = rewrite_query("RETURN gen_random_uuid ()");
480 assert_eq!(r.query, "RETURN $__graphd_uuid_0");
481 assert_eq!(r.generated_params.len(), 1);
482
483 let r2 = rewrite_query("RETURN gen_random_uuid\t( )");
484 assert_eq!(r2.query, "RETURN $__graphd_uuid_0");
485 assert_eq!(r2.generated_params.len(), 1);
486 }
487
488 #[test]
489 fn test_no_match_without_parens() {
490 let r = rewrite_query("RETURN gen_random_uuid AS alias");
491 assert_eq!(r.query, "RETURN gen_random_uuid AS alias");
492 assert!(r.generated_params.is_empty());
493 }
494
495 #[test]
496 fn test_no_match_with_args() {
497 let r = rewrite_query("RETURN gen_random_uuid(42)");
498 assert_eq!(r.query, "RETURN gen_random_uuid(42)");
499 assert!(r.generated_params.is_empty());
500 }
501
502 #[test]
503 fn test_preserves_surrounding_text() {
504 let r = rewrite_query("SELECT 1; gen_random_uuid(); SELECT 2");
505 assert_eq!(r.query, "SELECT 1; $__graphd_uuid_0; SELECT 2");
506 }
507
508 #[test]
509 fn test_merge_params_empty() {
510 let merged = merge_params(None, &[]);
511 assert!(merged.is_none());
512 }
513
514 #[test]
515 fn test_merge_params_only_user() {
516 let user = serde_json::json!({"name": "Alice"});
517 let merged = merge_params(Some(&user), &[]);
518 assert_eq!(merged, Some(user));
519 }
520
521 #[test]
522 fn test_merge_params_only_generated() {
523 let gen = vec![("__graphd_uuid_0".to_string(), serde_json::json!("abc-123"))];
524 let merged = merge_params(None, &gen).unwrap();
525 assert_eq!(merged["__graphd_uuid_0"], "abc-123");
526 }
527
528 #[test]
529 fn test_merge_params_both() {
530 let user = serde_json::json!({"name": "Alice"});
531 let gen = vec![("__graphd_uuid_0".to_string(), serde_json::json!("abc-123"))];
532 let merged = merge_params(Some(&user), &gen).unwrap();
533 assert_eq!(merged["name"], "Alice");
534 assert_eq!(merged["__graphd_uuid_0"], "abc-123");
535 }
536
537 #[test]
538 fn test_days_to_ymd_epoch() {
539 assert_eq!(days_to_ymd(0), (1970, 1, 1));
540 }
541
542 #[test]
543 fn test_days_to_ymd_known_date() {
544 assert_eq!(days_to_ymd(19737), (2024, 1, 15));
546 }
547
548 #[test]
549 fn test_days_to_ymd_leap_year() {
550 assert_eq!(days_to_ymd(19782), (2024, 2, 29));
552 }
553
554 #[test]
555 fn test_generated_uuid_is_valid_v4() {
556 let r = rewrite_query("RETURN gen_random_uuid()");
557 let val = r.generated_params[0].1.as_str().unwrap();
558 let parsed = uuid::Uuid::parse_str(val).unwrap();
559 assert_eq!(parsed.get_version_num(), 4);
560 }
561
562 #[test]
565 fn test_remove_property() {
566 let r = rewrite_query("MATCH (n:Person) REMOVE n.age");
567 assert_eq!(r.query, "MATCH (n:Person) SET n.age = NULL");
568 }
569
570 #[test]
571 fn test_remove_property_case_insensitive() {
572 let r = rewrite_query("MATCH (n) remove n.prop");
573 assert_eq!(r.query, "MATCH (n) SET n.prop = NULL");
574
575 let r2 = rewrite_query("MATCH (n) Remove n.prop");
576 assert_eq!(r2.query, "MATCH (n) SET n.prop = NULL");
577 }
578
579 #[test]
580 fn test_remove_property_extra_whitespace() {
581 let r = rewrite_query("MATCH (n) REMOVE n.prop");
582 assert_eq!(r.query, "MATCH (n) SET n.prop = NULL");
583 }
584
585 #[test]
586 fn test_remove_preserves_surrounding_query() {
587 let r = rewrite_query("MATCH (n:Person) REMOVE n.age RETURN n");
588 assert_eq!(r.query, "MATCH (n:Person) SET n.age = NULL RETURN n");
589 }
590
591 #[test]
592 fn test_remove_underscore_identifiers() {
593 let r = rewrite_query("MATCH (my_node) REMOVE my_node.some_prop");
594 assert_eq!(r.query, "MATCH (my_node) SET my_node.some_prop = NULL");
595 }
596
597 #[test]
598 fn test_remove_backtick_variable() {
599 let r = rewrite_query("MATCH (`my node`) REMOVE `my node`.prop");
600 assert_eq!(r.query, "MATCH (`my node`) SET `my node`.prop = NULL");
601 }
602
603 #[test]
604 fn test_remove_backtick_property() {
605 let r = rewrite_query("MATCH (n) REMOVE n.`weird prop`");
606 assert_eq!(r.query, "MATCH (n) SET n.`weird prop` = NULL");
607 }
608
609 #[test]
610 fn test_remove_not_in_string_literal() {
611 let r = rewrite_query("RETURN 'REMOVE n.prop' AS s");
612 assert_eq!(r.query, "RETURN 'REMOVE n.prop' AS s");
613 }
614
615 #[test]
616 fn test_remove_not_in_double_quote_string() {
617 let r = rewrite_query("RETURN \"REMOVE n.prop\" AS s");
618 assert_eq!(r.query, "RETURN \"REMOVE n.prop\" AS s");
619 }
620
621 #[test]
622 fn test_remove_label_not_rewritten() {
623 let r = rewrite_query("MATCH (n) REMOVE n:SomeLabel");
625 assert_eq!(r.query, "MATCH (n) REMOVE n:SomeLabel");
627 }
628
629 #[test]
630 fn test_remove_word_boundary() {
631 let r = rewrite_query("RETURN REMOVED AS alias");
633 assert_eq!(r.query, "RETURN REMOVED AS alias");
634 }
635
636 #[test]
637 fn test_remove_combined_with_function_rewrite() {
638 let r = rewrite_query("MATCH (n) REMOVE n.ts SET n.id = gen_random_uuid()");
640 assert_eq!(
641 r.query,
642 "MATCH (n) SET n.ts = NULL SET n.id = $__graphd_uuid_0"
643 );
644 assert_eq!(r.generated_params.len(), 1);
645 }
646}