less magic

Author: lovasoa

build.rs

@@ -17,7 +17,6 @@ async fn main() {
         .unwrap();
 
     println!("cargo:rerun-if-changed=build.rs");
-    generate_sqlpage_functions();
     let c = Rc::new(make_client());
 
     for h in [
@@ -36,35 +35,6 @@ async fn main() {
     set_odbc_rpath();
 }
 
-/// Lists the modules in `sqlpage_functions/functions/` into a `sqlpage_functions! { ... }` call, so
-/// built-in SQL functions register themselves just by having a file, with no hand-maintained list.
-fn generate_sqlpage_functions() {
-    const DIR: &str = "src/webserver/database/sqlpage_functions/functions";
-    println!("cargo:rerun-if-changed={DIR}");
-    let out = PathBuf::from(std::env::var("OUT_DIR").unwrap()).join("sqlpage_functions.rs");
-    let Ok(dir) = std::fs::read_dir(DIR) else {
-        // The source tree isn't present yet (e.g. the dependency-only Docker build stage, which
-        // compiles before `src/` is copied in). Emit an empty registry; once the directory exists
-        // the `rerun-if-changed` above makes the real build run this again.
-        std::fs::write(&out, "sqlpage_functions! {}\n").unwrap();
-        return;
-    };
-    let mut files: Vec<PathBuf> = dir
-        .map(|entry| entry.unwrap().path())
-        .filter(|path| path.extension().is_some_and(|ext| ext == "rs"))
-        .collect();
-    files.sort();
-    let entries: String = files
-        .iter()
-        .map(|path| {
-            let name = path.file_stem().unwrap().to_str().unwrap();
-            let abs = path.canonicalize().unwrap();
-            format!("    {name} = {abs:?},\n")
-        })
-        .collect();
-    std::fs::write(out, format!("sqlpage_functions! {{\n{entries}}}\n")).unwrap();
-}
-
 fn make_client() -> awc::Client {
     awc::ClientBuilder::new()
         .timeout(Duration::from_secs(10))

src/webserver/database/sqlpage_functions/README.md

@@ -1,34 +1,35 @@
 # Built-in SQL functions
 
-Each built-in `sqlpage.*` function is a plain `async fn` in its own file in [`functions/`](functions),
-with an ordinary Rust signature:
+Each built-in `sqlpage.*` function is a plain `async fn` in its own file in
+[`functions/`](functions). The file stem is the SQL function name and must match the Rust function it
+exports:
 
 ```rust
-#[allow(clippy::wildcard_imports)]
-use super::*;
+use std::borrow::Cow;
+
+use crate::webserver::http_request_info::RequestInfo;
 
 pub(super) async fn example(request: &RequestInfo, value: Option<Cow<'_, str>>) -> Option<String> {
     // ...
 }
 ```
 
-To register it, add one line to the list in [`functions.rs`](functions.rs), giving the SQL names of
-its arguments (used only in error messages):
+To add `sqlpage.example`, create `functions/example.rs` and add it to the
+[`sqlpage_functions!`](function_traits.rs) call in [`functions.rs`](functions.rs):
 
 ```rust
 sqlpage_functions! {
     // ...
-    example("value");
+    example,
 }
 ```
 
 The [`sqlpage_functions!`](function_traits.rs) macro declares the modules and generates the
-`SqlPageFunctionName` enum the SQL engine dispatches on. That is the only compile-time code: there is
-no build script involvement and no per-function generated code. Argument extraction, dispatch, and
-return-value conversion are handled generically in [`function_traits.rs`](function_traits.rs) by the
-`Extract`, `Handler`, and `IntoCowResult` traits. A function's argument and return types are read
-straight from its signature, so the supported argument types are exactly those that implement
-`Extract` (add an `impl` there to support a new one).
+`SqlPageFunctionName` enum the SQL engine dispatches on. Per-function argument extraction, dispatch,
+and return-value conversion are handled generically in [`function_traits.rs`](function_traits.rs) by
+the `Extract`, `Handler`, and `IntoCowResult` traits. A function's argument and return types are read
+straight from its signature, so supported argument types are the types that implement `Extract` there.
+Functions can take up to five arguments.
 
 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::*`.
+be made `pub(super)` and imported by name from sibling function modules.

src/webserver/database/sqlpage_functions/function_traits.rs

@@ -1,9 +1,9 @@
 //! Dispatch machinery for the built-in `sqlpage.*` SQL functions.
 //!
 //! Each function is a plain `async fn` in its own module under [`functions/`](super::functions).
-//! `build.rs` lists those modules and the [`sqlpage_functions!`] macro turns the list into the
-//! [`SqlPageFunctionName`](super::functions::SqlPageFunctionName) enum the engine dispatches on, so
-//! functions register themselves just by existing. Adapting each signature to the uniform
+//! [`sqlpage_functions!`] turns the module list in [`functions`](super::functions) into the
+//! [`SqlPageFunctionName`](super::functions::SqlPageFunctionName) enum the engine dispatches on.
+//! Adapting each signature to the uniform
 //! `(request, db, args) -> Option<string>` convention is done generically by [`Extract`] (per
 //! argument type), [`Handler`] (per argument count, the trick `axum` uses) and [`IntoCowResult`]
 //! (per return type); the macro itself carries no type-level glue.
@@ -217,17 +217,11 @@ impl<'a, T: IntoCow<'a>> IntoCow<'a> for Option<T> {
 }
 
 /// Declares the listed function modules and builds the [`SqlPageFunctionName`] dispatch enum from
-/// them. The list is produced by `build.rs`, so there is no hand-maintained registry.
+/// them.
 macro_rules! sqlpage_functions {
-    ($($func:ident = $path:literal),* $(,)?) => {
+    ($($func:ident),* $(,)?) => {
         $(
-            // `build.rs` passes the absolute path because the `mod` is expanded from a file
-            // `include!`d out of `OUT_DIR`, where the default relative lookup would not find it.
-            #[path = $path]
             mod $func;
-            // Re-export so sibling modules can use each other's helpers via `use super::*`.
-            #[allow(unused_imports)]
-            use $func::*;
         )*
 
         /// One variant per built-in `sqlpage.*` function.
@@ -238,12 +232,20 @@ macro_rules! sqlpage_functions {
         }
 
         impl SqlPageFunctionName {
+            const ALL: &'static [Self] = &[$(Self::$func),*];
+
+            fn name(self) -> &'static str {
+                match self {
+                    $(Self::$func => stringify!($func)),*
+                }
+            }
+
             pub(crate) async fn evaluate<'a, 'c>(
                 self,
-                request: &'a ExecutionContext,
-                db_connection: &'c mut DbConn,
-                arguments: Vec<Option<Cow<'a, str>>>,
-            ) -> anyhow::Result<Option<Cow<'a, str>>>
+                request: &'a $crate::webserver::http_request_info::ExecutionContext,
+                db_connection: &'c mut $crate::webserver::database::execute_queries::DbConn,
+                arguments: Vec<Option<::std::borrow::Cow<'a, str>>>,
+            ) -> anyhow::Result<Option<::std::borrow::Cow<'a, str>>>
             where
                 'a: 'c,
             {
@@ -256,32 +258,6 @@ macro_rules! sqlpage_functions {
                 }
             }
         }
-
-        impl ::std::str::FromStr for SqlPageFunctionName {
-            type Err = anyhow::Error;
-
-            fn from_str(name: &str) -> anyhow::Result<Self> {
-                match name {
-                    $(stringify!($func) => Ok(SqlPageFunctionName::$func),)*
-                    unknown => anyhow::bail!(
-                        "Unknown function {unknown:?}. Supported functions:\n{}",
-                        [$(SqlPageFunctionName::$func),*]
-                            .iter()
-                            .map(|f| format!("  - {f}\n"))
-                            .collect::<String>()
-                    ),
-                }
-            }
-        }
-
-        impl ::std::fmt::Display for SqlPageFunctionName {
-            fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
-                f.write_str("sqlpage.")?;
-                f.write_str(match self {
-                    $(SqlPageFunctionName::$func => stringify!($func)),*
-                })
-            }
-        }
     };
 }
 

src/webserver/database/sqlpage_functions/functions.rs

@@ -1,38 +1,83 @@
 //! Built-in `SQLPage` SQL functions.
 //!
 //! Every function is a plain `async fn` in its own module under [`functions/`](self). To add one,
-//! just create `functions/<name>.rs` with an `async fn <name>`: `build.rs` discovers it and emits
-//! a [`sqlpage_functions!`](super::function_traits::sqlpage_functions) call (the file `include!`d
-//! below) that declares the module and adds it to the dispatch enum. Argument conversion and
+//! create `functions/<name>.rs` with an `async fn <name>` and add it to the
+//! [`sqlpage_functions!`](super::function_traits::sqlpage_functions) call below. The macro declares
+//! the module and adds it to the dispatch enum. Argument conversion and
 //! dispatch are handled generically in [`super::function_traits`].
 
-// Every function module reaches the shared imports below, and its siblings' `pub(super)` helpers,
-// through `use super::*`. Allow it once here rather than on each module.
-#![allow(clippy::wildcard_imports)]
-
-use super::{ExecutionContext, RequestInfo};
-use crate::filesystem::FileAccess;
-use crate::webserver::{
-    ErrorWithStatus,
-    database::{
-        blob_to_data_url::vec_to_data_uri_with_mime,
-        execute_queries::DbConn,
-        sqlpage_functions::{http_fetch_request::HttpFetchRequest, url_parameters::URLParameters},
-    },
-    http_client::make_http_client,
-    request_variables::SetVariablesMap,
-    single_or_vec::SingleOrVec,
-};
-use anyhow::{Context, anyhow};
-use futures_util::StreamExt;
-use mime_guess::mime;
-use opentelemetry_semantic_conventions::attribute as otel;
 use std::fmt::Write;
-use std::{borrow::Cow, ffi::OsStr, str::FromStr};
-use tracing::Instrument;
 
 use super::function_traits::sqlpage_functions;
 
-// Generated by build.rs: a `sqlpage_functions!` call listing every module file in `functions/`.
-// Discovering them there is what frees us from a hand-maintained registry.
-include!(concat!(env!("OUT_DIR"), "/sqlpage_functions.rs"));
+sqlpage_functions! {
+    basic_auth_password,
+    basic_auth_username,
+    client_ip,
+    configuration_directory,
+    cookie,
+    current_working_directory,
+    environment_variable,
+    exec,
+    fetch,
+    fetch_with_meta,
+    hash_password,
+    header,
+    headers,
+    hmac,
+    link,
+    oidc_logout_url,
+    path,
+    persist_uploaded_file,
+    protocol,
+    random_string,
+    read_file_as_data_url,
+    read_file_as_text,
+    regex_match,
+    request_body,
+    request_body_base64,
+    request_method,
+    run_sql,
+    set_variable,
+    uploaded_file_mime_type,
+    uploaded_file_name,
+    uploaded_file_path,
+    url_encode,
+    user_info,
+    user_info_token,
+    variables,
+    version,
+    web_root,
+}
+
+impl ::std::str::FromStr for SqlPageFunctionName {
+    type Err = anyhow::Error;
+
+    fn from_str(name: &str) -> anyhow::Result<Self> {
+        SqlPageFunctionName::ALL
+            .iter()
+            .copied()
+            .find(|function| function.name() == name)
+            .ok_or_else(|| {
+                anyhow::anyhow!(
+                    "Unknown function {name:?}. Supported functions:\n{}",
+                    supported_function_list()
+                )
+            })
+    }
+}
+
+impl ::std::fmt::Display for SqlPageFunctionName {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
+        f.write_str("sqlpage.")?;
+        f.write_str(self.name())
+    }
+}
+
+fn supported_function_list() -> String {
+    let mut supported = String::new();
+    for function in SqlPageFunctionName::ALL {
+        writeln!(supported, "  - {function}").expect("writing to a String cannot fail");
+    }
+    supported
+}

src/webserver/database/sqlpage_functions/functions/basic_auth_password.rs

@@ -1,4 +1,6 @@
-use super::*;
+use anyhow::Context;
+
+use crate::webserver::{ErrorWithStatus, http_request_info::RequestInfo};
 
 /// Returns the password from the HTTP basic auth header, if present.
 pub(super) async fn basic_auth_password(request: &RequestInfo) -> anyhow::Result<&str> {

src/webserver/database/sqlpage_functions/functions/basic_auth_username.rs

@@ -1,4 +1,6 @@
-use super::*;
+use crate::webserver::http_request_info::RequestInfo;
+
+use super::basic_auth_password::extract_basic_auth;
 
 /// Returns the username from the HTTP basic auth header, if present.
 /// Otherwise, returns an HTTP 401 Unauthorized error.

src/webserver/database/sqlpage_functions/functions/client_ip.rs

@@ -1,4 +1,4 @@
-use super::*;
+use crate::webserver::http_request_info::RequestInfo;
 
 pub(super) async fn client_ip(request: &RequestInfo) -> Option<String> {
     Some(request.client_ip?.to_string())

src/webserver/database/sqlpage_functions/functions/configuration_directory.rs

@@ -1,4 +1,4 @@
-use super::*;
+use crate::webserver::http_request_info::RequestInfo;
 
 /// Returns the directory where the sqlpage.json configuration file, templates, and migrations are located.
 pub(super) async fn configuration_directory(request: &RequestInfo) -> String {

src/webserver/database/sqlpage_functions/functions/cookie.rs

@@ -1,4 +1,6 @@
-use super::*;
+use std::borrow::Cow;
+
+use crate::webserver::{http_request_info::RequestInfo, single_or_vec::SingleOrVec};
 
 pub(super) async fn cookie<'a>(request: &'a RequestInfo, name: Cow<'a, str>) -> Option<Cow<'a, str>> {
     request.cookies.get(&*name).map(SingleOrVec::as_json_str)

src/webserver/database/sqlpage_functions/functions/current_working_directory.rs

@@ -1,4 +1,4 @@
-use super::*;
+use anyhow::Context;
 
 pub(super) async fn current_working_directory() -> anyhow::Result<String> {
     std::env::current_dir()