use mlua::{Lua, Table, Value};
use crate::config::{EnvOptions, RunMode};
const DEFAULT_SECRET_MIN_LEN: usize = 32;
pub(crate) fn create_env_table(lua: &Lua, opts: &EnvOptions) -> mlua::Result<Table> {
let env = lua.create_table()?;
let policy = opts.clone();
env.set(
"get",
lua.create_function(move |lua, (name, default): (String, Option<Value>)| {
match read(lua, &policy, &name) {
Some(v) => Ok(Value::String(lua.create_string(&v)?)),
None => Ok(default.unwrap_or(Value::Nil)),
}
})?,
)?;
let policy = opts.clone();
env.set(
"has",
lua.create_function(move |lua, name: String| Ok(read(lua, &policy, &name).is_some()))?,
)?;
let policy = opts.clone();
env.set(
"number",
lua.create_function(move |lua, (name, default): (String, Option<Value>)| {
let parsed = read(lua, &policy, &name)
.and_then(|v| v.trim().parse::<f64>().ok())
.filter(|n| n.is_finite());
match parsed {
Some(n) => Ok(Value::Number(n)),
None => Ok(default.unwrap_or(Value::Nil)),
}
})?,
)?;
let policy = opts.clone();
env.set(
"bool",
lua.create_function(move |lua, (name, default): (String, Option<Value>)| {
match read(lua, &policy, &name).as_deref().and_then(parse_bool) {
Some(b) => Ok(Value::Boolean(b)),
None => Ok(default.unwrap_or(Value::Nil)),
}
})?,
)?;
let policy = opts.clone();
env.set(
"secret",
lua.create_function(move |lua, (name, opts): (String, Option<Table>)| {
let (min_len, dev) = match opts {
Some(opts) => (
opts.get::<Option<usize>>("min_len")?,
opts.get::<Option<String>>("dev")?,
),
None => (None, None),
};
let min_len = min_len.unwrap_or(DEFAULT_SECRET_MIN_LEN);
let value = match read(lua, &policy, &name) {
Some(value) => value,
None if run_mode(lua, &policy) != RunMode::Run => match dev {
Some(fallback) => fallback,
None => return Err(missing_secret(&name)),
},
None => return Err(missing_secret(&name)),
};
if value.len() < min_len {
return Err(mlua::Error::RuntimeError(format!(
"the secret in {name} is {} bytes long, at least {min_len} are required",
value.len()
)));
}
lua.create_string(value)
})?,
)?;
env.set("mode", opts.mode.as_str())?;
Ok(env)
}
fn run_mode(lua: &Lua, opts: &EnvOptions) -> RunMode {
lua.app_data_ref::<RunMode>()
.map_or(opts.mode, |mode| *mode)
}
pub fn set_run_mode(lua: &Lua, mode: RunMode) -> mlua::Result<()> {
lua.set_app_data(mode);
let nitr = nitr_core::nitr_table(lua).map_err(mlua::Error::external)?;
if let Some(env) = nitr.get::<Option<Table>>("env")? {
env.set("mode", mode.as_str())?;
}
Ok(())
}
fn missing_secret(name: &str) -> mlua::Error {
mlua::Error::RuntimeError(format!(
"the environment variable {name} is required and has no value"
))
}
fn read(lua: &Lua, opts: &EnvOptions, name: &str) -> Option<String> {
if !visible(opts, name) {
return None;
}
let value = match crate::testing::installed(lua).and_then(|d| d.env_override(name)) {
Some(overridden) => overridden,
None => std::env::var(name).ok(),
};
value.filter(|value| !value.is_empty())
}
fn visible(opts: &EnvOptions, name: &str) -> bool {
if name.starts_with("NITR_") {
return false;
}
match &opts.allow {
None => true,
Some(allow) => allow.iter().any(|entry| {
match entry.strip_suffix('_') {
Some(_) => name.starts_with(entry.as_str()),
None => name == entry,
}
}),
}
}
fn parse_bool(value: &str) -> Option<bool> {
match value.trim().to_ascii_lowercase().as_str() {
"1" | "true" | "yes" | "on" => Some(true),
"0" | "false" | "no" | "off" | "" => Some(false),
_ => None,
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn nitr_internals_are_always_hidden() {
let open = EnvOptions::default();
assert!(!visible(&open, "NITR_DATABASE_PATH"));
assert!(!visible(&open, "NITR_ANYTHING"));
assert!(visible(&open, "HOME"));
}
#[test]
fn the_allow_list_matches_prefixes_and_exact_names() {
let opts = EnvOptions {
allow: Some(vec!["APP_".into(), "API_TOKEN".into()]),
mode: RunMode::Run,
};
assert!(visible(&opts, "APP_NAME"));
assert!(visible(&opts, "API_TOKEN"));
assert!(!visible(&opts, "API_TOKEN_2"), "exact means exact");
assert!(!visible(&opts, "APPLE"), "prefix requires the underscore");
assert!(!visible(&opts, "HOME"));
let opts = EnvOptions {
allow: Some(vec!["NITR_".into()]),
mode: RunMode::Run,
};
assert!(!visible(&opts, "NITR_LISTEN"));
}
#[test]
fn env_flags_parse_conventionally() {
for yes in ["1", "true", "YES", "On", " true "] {
assert_eq!(parse_bool(yes), Some(true), "{yes}");
}
for no in ["0", "false", "NO", "off", ""] {
assert_eq!(parse_bool(no), Some(false), "{no}");
}
assert_eq!(parse_bool("maybe"), None);
}
#[test]
fn lua_getters_answer_defaults_for_unset_names() {
let lua = mlua::Lua::new();
let table = create_env_table(&lua, &EnvOptions::default()).expect("table");
lua.globals().set("env", table).expect("set");
let (a, b, c, d): (Value, String, f64, bool) = lua
.load(
r#"return env.get("NITR_STD_SURELY_UNSET"),
env.get("NITR_STD_SURELY_UNSET", "fallback"),
env.number("NITR_STD_SURELY_UNSET", 42),
env.bool("NITR_STD_SURELY_UNSET", true)"#,
)
.eval()
.expect("eval");
assert!(a.is_nil());
assert_eq!(b, "fallback");
assert_eq!(c, 42.0);
assert!(d);
}
#[test]
fn an_empty_variable_reads_as_unset() {
let lua = mlua::Lua::new();
let doubles = crate::testing::Doubles::new();
lua.set_app_data(doubles.clone());
let table = create_env_table(&lua, &EnvOptions::default()).expect("table");
lua.globals().set("env", table).expect("set");
doubles.set_env("APP_EMPTY", Some(String::new()));
let (value, has, number, flag): (String, bool, f64, bool) = lua
.load(
r#"return env.get("APP_EMPTY", "d"), env.has("APP_EMPTY"),
env.number("APP_EMPTY", 7), env.bool("APP_EMPTY", true)"#,
)
.eval()
.expect("eval");
assert_eq!((value.as_str(), has, number, flag), ("d", false, 7.0, true));
}
#[test]
fn secret_fails_closed_and_the_fallback_is_for_development_only() {
for (mode, fallback_ok) in [
(RunMode::Run, false),
(RunMode::Dev, true),
(RunMode::Test, true),
] {
let lua = mlua::Lua::new();
let doubles = crate::testing::Doubles::new();
lua.set_app_data(doubles.clone());
let opts = EnvOptions { allow: None, mode };
let table = create_env_table(&lua, &opts).expect("table");
lua.globals().set("env", table).expect("set");
let got: String = lua.load("return env.mode").eval().expect("mode");
assert_eq!(got, mode.as_str());
let mode = mode.as_str();
let err = lua
.load(r#"return env.secret("APP_KEY")"#)
.eval::<String>()
.expect_err("unset")
.to_string();
assert!(
err.contains("APP_KEY") && err.contains("required"),
"{mode}: {err}"
);
let fallback = lua
.load(
r#"return env.secret("APP_KEY", { dev = "dev-only-key-0123456789abcdef012" })"#,
)
.eval::<String>();
if fallback_ok {
assert_eq!(fallback.expect(mode), "dev-only-key-0123456789abcdef012");
} else {
let err = fallback.expect_err(mode).to_string();
assert!(err.contains("APP_KEY"), "{mode}: {err}");
}
doubles.set_env("APP_KEY", Some("short".into()));
let err = lua
.load(r#"return env.secret("APP_KEY")"#)
.eval::<String>()
.expect_err("short")
.to_string();
assert!(
err.contains("32") && err.contains("APP_KEY"),
"{mode}: {err}"
);
let ok: String = lua
.load(r#"return env.secret("APP_KEY", { min_len = 5 })"#)
.eval()
.expect("min_len");
assert_eq!(ok, "short");
doubles.set_env("APP_KEY", Some("x".repeat(32)));
let ok: String = lua
.load(r#"return env.secret("APP_KEY")"#)
.eval()
.expect("set");
assert_eq!(ok.len(), 32);
}
}
#[test]
fn the_run_mode_can_be_set_after_registration() {
let lua = mlua::Lua::new();
let doubles = crate::testing::Doubles::new();
lua.set_app_data(doubles);
let nitr = nitr_core::nitr_table(&lua).expect("nitr");
let table = create_env_table(&lua, &EnvOptions::default()).expect("table");
nitr.set("env", table).expect("set");
lua.globals().set("nitr", nitr).expect("set");
let run =
r#"return nitr.env.mode, pcall(nitr.env.secret, "APP_KEY", { dev = ("k"):rep(32) })"#;
let (mode, ok): (String, bool) = lua.load(run).eval().expect("run");
assert_eq!((mode.as_str(), ok), ("run", false));
set_run_mode(&lua, RunMode::Test).expect("set mode");
let (mode, ok): (String, bool) = lua.load(run).eval().expect("test");
assert_eq!((mode.as_str(), ok), ("test", true));
}
#[test]
fn number_refuses_non_finite_values() {
let lua = mlua::Lua::new();
let doubles = crate::testing::Doubles::new();
lua.set_app_data(doubles.clone());
let table = create_env_table(&lua, &EnvOptions::default()).expect("table");
lua.globals().set("env", table).expect("set");
for value in ["nan", "inf", "-inf", "NaN"] {
doubles.set_env("APP_LIMIT", Some(value.into()));
let n: f64 = lua
.load(r#"return env.number("APP_LIMIT", 7)"#)
.eval()
.expect("eval");
assert_eq!(n, 7.0, "{value}");
}
doubles.set_env("APP_LIMIT", Some("2.5".into()));
let n: f64 = lua
.load(r#"return env.number("APP_LIMIT", 7)"#)
.eval()
.expect("eval");
assert_eq!(n, 2.5);
}
#[test]
fn overrides_obey_the_policy() {
let lua = mlua::Lua::new();
let doubles = crate::testing::Doubles::new();
lua.set_app_data(doubles.clone());
let opts = EnvOptions {
allow: Some(vec!["APP_".into(), "PATH".into()]),
mode: RunMode::Run,
};
let table = create_env_table(&lua, &opts).expect("table");
lua.globals().set("env", table).expect("set");
doubles.set_env("APP_KEY", Some("sk_test_1".into()));
doubles.set_env("SECRET", Some("leaked".into()));
doubles.set_env("NITR_LISTEN", Some("leaked".into()));
doubles.set_env("PATH", None);
let (key, secret, internal, path, has_path): (String, Value, Value, Value, bool) = lua
.load(
r#"return env.get("APP_KEY"), env.get("SECRET"), env.get("NITR_LISTEN"),
env.get("PATH"), env.has("PATH")"#,
)
.eval()
.expect("eval");
assert_eq!(key, "sk_test_1");
assert!(secret.is_nil(), "outside the allow list stays hidden");
assert!(internal.is_nil(), "NITR_* stays hidden");
assert!(path.is_nil() && !has_path, "an explicit unset wins");
doubles.reset();
let path: Value = lua.load(r#"return env.get("PATH")"#).eval().expect("eval");
assert!(!path.is_nil(), "reset restores the process environment");
}
}