refactor: split SQLPage functions into modules

Author: lovasoa

build.rs

@@ -2,6 +2,7 @@ use actix_rt::spawn;
 use actix_rt::time::sleep;
 use libflate::gzip;
 use std::collections::hash_map::DefaultHasher;
+use std::fmt::Write as _;
 use std::fs::File;
 use std::hash::Hasher;
 use std::io::Read;
@@ -17,6 +18,7 @@ async fn main() {
         .unwrap();
 
     println!("cargo:rerun-if-changed=build.rs");
+    generate_sqlpage_functions();
     let c = Rc::new(make_client());
 
     for h in [
@@ -35,6 +37,54 @@ async fn main() {
     set_odbc_rpath();
 }
 
+const SQLPAGE_FUNCTION_MARKER: &str = "// sqlpage-function: ";
+
+/// Generates the built-in SQL function module declarations and registry from one file per function.
+fn generate_sqlpage_functions() {
+    let functions_dir = Path::new("src/webserver/database/sqlpage_functions/functions");
+    println!("cargo:rerun-if-changed={}", functions_dir.display());
+
+    let mut functions = std::fs::read_dir(functions_dir)
+        .unwrap()
+        .map(|entry| entry.unwrap().path())
+        .filter(|path| path.extension().is_some_and(|extension| extension == "rs"))
+        .collect::<Vec<_>>();
+    functions.sort();
+
+    let mut generated = String::from("// @generated by build.rs; do not edit.\n\n");
+    let mut definitions = String::new();
+    for path in functions {
+        let module_name = path.file_stem().unwrap().to_str().unwrap();
+        let source = std::fs::read_to_string(&path).unwrap();
+        let definition = source
+            .lines()
+            .find_map(|line| line.strip_prefix(SQLPAGE_FUNCTION_MARKER))
+            .unwrap_or_else(|| {
+                panic!(
+                    "{} has no {SQLPAGE_FUNCTION_MARKER:?} declaration",
+                    path.display()
+                )
+            });
+        assert!(
+            definition.starts_with(&format!("{module_name}(")),
+            "The function declared in {} must match its file name",
+            path.display()
+        );
+        let canonical_path = path.canonicalize().unwrap();
+        writeln!(generated, "#[path = {canonical_path:?}]").unwrap();
+        writeln!(generated, "mod {module_name};").unwrap();
+        writeln!(generated, "#[allow(clippy::wildcard_imports)]").unwrap();
+        writeln!(generated, "use {module_name}::*;\n").unwrap();
+        writeln!(definitions, "    {definition}").unwrap();
+    }
+    generated.push_str("super::function_definition_macro::sqlpage_functions! {\n");
+    generated.push_str(&definitions);
+    generated.push_str("}\n");
+
+    let out_dir = PathBuf::from(std::env::var("OUT_DIR").unwrap());
+    std::fs::write(out_dir.join("sqlpage_functions.rs"), generated).unwrap();
+}
+
 fn make_client() -> awc::Client {
     awc::ClientBuilder::new()
         .timeout(Duration::from_secs(10))

src/webserver/database/sqlpage_functions/README.md

@@ -0,0 +1,23 @@
+# Built-in SQL functions
+
+Each built-in `sqlpage.*` function lives in one Rust file in [`functions/`](functions).
+The file name must match the SQL function name and the file must contain a declaration marker:
+
+```rust
+// sqlpage-function: example((&RequestInfo), value: Option<Cow<str>>);
+
+#[allow(clippy::wildcard_imports)]
+use super::*;
+
+pub(super) async fn example(request: &RequestInfo, value: Option<Cow<'_, str>>) -> Option<String> {
+    // ...
+}
+```
+
+At compile time, `build.rs` scans every `.rs` file in `functions/`, generates the module declarations,
+and passes all marker declarations to `sqlpage_functions!`, which generates the function-name registry,
+argument conversion, and dispatch code. Adding a correctly named file is therefore enough to register a
+new SQLPage function; do not edit generated files in `OUT_DIR`.
+
+Keep helpers and unit tests that are specific to a function in that function's file. Shared helpers can be
+made `pub(super)` and used by sibling function modules through `use super::*`.