#![cfg_attr(not(test), deny(clippy::unwrap_used, clippy::expect_used))]
#![cfg_attr(docsrs, feature(doc_cfg))]
use std::path::PathBuf;
use nitr_core::Result;
pub(crate) mod base64;
pub(crate) mod bounded;
pub mod cache;
pub mod clock;
pub(crate) mod config;
#[cfg(feature = "crypto")]
pub(crate) mod crypto;
pub(crate) mod csrf;
#[cfg(feature = "db")]
pub(crate) mod db;
pub(crate) mod env;
#[cfg(feature = "fetch")]
pub(crate) mod fetch;
pub(crate) mod http;
pub(crate) mod json;
pub(crate) mod log;
pub(crate) mod path;
pub(crate) mod session;
#[cfg(feature = "template")]
pub(crate) mod template;
pub mod testing;
pub(crate) mod time;
pub(crate) mod url;
pub(crate) mod utils;
pub(crate) mod validate;
pub use cache::{Cache, CacheOptions};
pub mod validation {
pub use crate::validate::format::{CustomFormatInfo, custom_formats};
pub use crate::validate::media::{
Detection, MEDIA_TYPES, MediaType, SNIFF_BYTES, detect, dimensions, executable_extension,
is_active_content, is_text, lookup, text_subtype_matches,
};
pub use crate::validate::message::{fmt_size, rule_codes};
pub use crate::validate::schema_json::{Components, regex_escape};
pub use crate::validate::{
CompiledSchema, DocSchema, ErrorEntry, FileInfo, LuaFile, SaveResolver, TextValue,
ValidationError, compile_doc_schema, compile_file_rule, compile_schema,
compile_text_schema, freeze_messages,
};
}
pub use config::{EnvOptions, FetchOptions, MAX_PASSWORD_BYTES, RunMode, SqlitePragmas};
pub use env::set_run_mode;
pub use http::{
RequestCookies, ResponseCookies, SetCookie, best_match, parse_set_cookie, response_table,
};
pub use utils::error_lua_value;
#[doc(hidden)]
pub mod fuzzing {
#[cfg(feature = "crypto")]
pub use crate::crypto::{VERIFY_REASONS, create_auth_table, create_crypto_table};
pub use crate::http::{sign, verify};
pub use crate::json::create_json_fn;
pub use crate::path::{
basename, dirname, is_absolute, is_windows_style, join, normalize, split_root,
};
pub use crate::url::create_url_table;
pub use crate::utils::check_json_bounds;
pub use crate::validate::coerce_for_fuzzing;
pub use crate::validate::exemplars::FORMAT_EXEMPLARS;
pub use crate::validate::format::{check_format, format_names};
pub use crate::validate::media::{detect as sniff_file, dimensions as sniff_dimensions};
}
#[cfg(feature = "db")]
pub use db::migrate;
#[cfg(feature = "db")]
pub use db::pragmas::open as db_open;
#[cfg(feature = "db")]
pub use db::testing as db_fixtures;
#[cfg(feature = "fetch")]
pub use fetch::{reset_outbound_budget, set_trace_context};
pub fn json_encode(value: &mlua::Value) -> mlua::Result<Vec<u8>> {
bounded::to_json_vec(value).map_err(mlua::Error::external)
}
#[cfg(not(feature = "fetch"))]
pub fn reset_outbound_budget(_lua: &mlua::Lua) {}
#[cfg(not(feature = "fetch"))]
pub fn set_trace_context(_lua: &mlua::Lua, _request_id: &str) {}
bitflags::bitflags! {
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub struct Builtins: u32 {
const DEBUG = 1;
const FETCH = 1 << 1;
const TEMPLATE = 1 << 2;
const JSON = 1 << 3;
const DATABASE = 1 << 4;
const HTTP = 1 << 5;
const LOG = 1 << 6;
const CRYPTO = 1 << 7;
const CACHE = 1 << 8;
const TIME = 1 << 9;
const VALIDATE = 1 << 10;
const BASE64 = 1 << 11;
const PATH = 1 << 12;
const URL = 1 << 13;
const ENV = 1 << 14;
}
}
impl Builtins {
pub const fn minimal() -> Self {
Self::JSON
.union(Self::HTTP)
.union(Self::LOG)
.union(Self::TIME)
.union(Self::VALIDATE)
.union(Self::BASE64)
.union(Self::PATH)
.union(Self::URL)
}
pub fn nitr_name(self) -> Option<&'static str> {
match self {
Builtins::DEBUG => Some("dbg"),
Builtins::FETCH => Some("fetch"),
Builtins::TEMPLATE => Some("template"),
Builtins::JSON => Some("json"),
Builtins::DATABASE => Some("db"),
Builtins::LOG => Some("log"),
Builtins::TIME => Some("time"),
Builtins::VALIDATE => Some("validate"),
Builtins::BASE64 => Some("base64"),
Builtins::PATH => Some("path"),
Builtins::URL => Some("url"),
Builtins::ENV => Some("env"),
_ => None,
}
}
pub fn from_config_name(name: &str) -> Option<Self> {
match name {
"dbg" => Some(Builtins::DEBUG),
"fetch" => Some(Builtins::FETCH),
"template" => Some(Builtins::TEMPLATE),
"json" => Some(Builtins::JSON),
"db" => Some(Builtins::DATABASE),
"http" => Some(Builtins::HTTP),
"log" => Some(Builtins::LOG),
"crypto" => Some(Builtins::CRYPTO),
"cache" => Some(Builtins::CACHE),
"time" => Some(Builtins::TIME),
"validate" => Some(Builtins::VALIDATE),
"base64" => Some(Builtins::BASE64),
"path" => Some(Builtins::PATH),
"url" => Some(Builtins::URL),
"env" => Some(Builtins::ENV),
_ => None,
}
}
}
#[derive(Debug, Clone, Default)]
pub struct BuiltinsEnv {
pub templates_dir: Option<PathBuf>,
pub database: Option<PathBuf>,
pub sqlite: SqlitePragmas,
pub cache: Option<Cache>,
pub fetch: FetchOptions,
pub env: EnvOptions,
pub cookie_secure: bool,
pub cookie_insecure_warning: Option<String>,
}
#[cfg(not(all(
feature = "crypto",
feature = "db",
feature = "fetch",
feature = "template"
)))]
fn not_compiled_in(name: &str) -> nitr_core::Error {
nitr_core::Error::Config(format!(
"the `{name}` builtin is configured but was not compiled into this \
binary: rebuild with the `{name}` Cargo feature (or `all`), or drop \
it from `[std] features`"
))
}
pub fn register_builtins(lua: &mlua::Lua, builtins: Builtins, env: &BuiltinsEnv) -> Result {
let nitr = nitr_core::nitr_table(lua)?;
lua.set_app_data(http::CookieDefaults {
secure: env.cookie_secure,
insecure_warning: env.cookie_insecure_warning.clone(),
});
for builtin in builtins.iter() {
match builtin {
Builtins::DEBUG => nitr.set("dbg", utils::create_debug_fn(lua)?)?,
#[cfg(feature = "fetch")]
Builtins::FETCH => {
let opts = std::sync::Arc::new(env.fetch.clone());
nitr.set("fetch", fetch::create_fetch_fn(lua, opts.clone())?)?;
nitr.set("await_all", fetch::create_await_all_fn(lua, opts)?)?;
}
#[cfg(not(feature = "fetch"))]
Builtins::FETCH => return Err(not_compiled_in("fetch")),
#[cfg(feature = "template")]
Builtins::TEMPLATE => match &env.templates_dir {
Some(dir) => nitr.set("template", template::create_template_fn(lua, dir)?)?,
None => {
tracing::warn!(
"skipping builtin `template`: `[templating] dir` is not configured"
);
}
},
#[cfg(not(feature = "template"))]
Builtins::TEMPLATE => return Err(not_compiled_in("template")),
Builtins::JSON => nitr.set("json", json::create_json_fn(lua)?)?,
Builtins::HTTP => {
http::register(lua, &nitr)?;
nitr.set("csrf", csrf::create_csrf_table(lua)?)?;
nitr.set("session", session::create_session_fn(lua)?)?;
}
Builtins::LOG => nitr.set("log", log::create_log_table(lua)?)?,
Builtins::TIME => nitr.set("time", time::create_time_table(lua)?)?,
Builtins::VALIDATE => nitr.set("validate", validate::create_validate_table(lua)?)?,
Builtins::BASE64 => nitr.set("base64", base64::create_base64_table(lua)?)?,
Builtins::PATH => nitr.set("path", path::create_path_table(lua)?)?,
Builtins::URL => nitr.set("url", url::create_url_table(lua)?)?,
Builtins::ENV => nitr.set("env", env::create_env_table(lua, &env.env)?)?,
#[cfg(feature = "crypto")]
Builtins::CRYPTO => {
nitr.set("crypto", crypto::create_crypto_table(lua)?)?;
nitr.set("auth", crypto::create_auth_table(lua)?)?;
}
#[cfg(not(feature = "crypto"))]
Builtins::CRYPTO => return Err(not_compiled_in("crypto")),
#[cfg(feature = "db")]
Builtins::DATABASE => match &env.database {
Some(path) => nitr.set("db", db::create_database_fn(lua, path, &env.sqlite)?)?,
None => {
tracing::warn!("skipping builtin `db`: `database` is not configured");
}
},
#[cfg(not(feature = "db"))]
Builtins::DATABASE => return Err(not_compiled_in("db")),
Builtins::CACHE => match &env.cache {
Some(cache) => nitr.set("cache", cache::create_cache(lua, cache.clone())?)?,
None => {
tracing::warn!("skipping builtin `cache`: no shared cache was provided");
}
},
_ => continue,
};
}
nitr.set("errinfo", utils::create_errinfo_fn(lua)?)?;
Ok(())
}
#[cfg(test)]
mod tests {
use super::Builtins;
#[test]
fn config_names_round_trip() {
for (name, flag) in [
("dbg", Builtins::DEBUG),
("fetch", Builtins::FETCH),
("template", Builtins::TEMPLATE),
("json", Builtins::JSON),
("db", Builtins::DATABASE),
("http", Builtins::HTTP),
("log", Builtins::LOG),
("crypto", Builtins::CRYPTO),
("time", Builtins::TIME),
("validate", Builtins::VALIDATE),
("base64", Builtins::BASE64),
("path", Builtins::PATH),
("url", Builtins::URL),
("env", Builtins::ENV),
] {
assert_eq!(Builtins::from_config_name(name), Some(flag));
}
assert_eq!(Builtins::from_config_name("nope"), None);
assert_eq!((Builtins::DEBUG | Builtins::JSON).nitr_name(), None);
assert_eq!(Builtins::HTTP.nitr_name(), None);
assert_eq!(Builtins::DATABASE.nitr_name(), Some("db"));
}
}