Skip to main content

turbo_tasks_env/
lib.rs

1#![feature(arbitrary_self_types)]
2#![feature(arbitrary_self_types_pointers)]
3
4mod command_line;
5mod custom;
6mod dotenv;
7mod filter;
8
9use std::{env, sync::Mutex};
10
11use anyhow::Result;
12use turbo_rcstr::RcStr;
13use turbo_tasks::{FxIndexMap, Vc};
14
15pub use self::{
16    command_line::CommandLineProcessEnv, custom::CustomProcessEnv, dotenv::DotenvProcessEnv,
17    filter::FilterProcessEnv,
18};
19
20/// Like [`EnvMap`], but with `serialization = "skip"` to avoid storing
21/// environment variables (which may contain secrets) in the persistent cache.
22#[turbo_tasks::value(transparent, serialization = "skip")]
23pub struct TransientEnvMap(FxIndexMap<RcStr, RcStr>);
24
25#[turbo_tasks::value_impl]
26impl TransientEnvMap {
27    #[turbo_tasks::function]
28    pub fn empty() -> Vc<Self> {
29        TransientEnvMap(FxIndexMap::default()).cell()
30    }
31}
32
33/// A map of environment variables.
34#[turbo_tasks::value(transparent, cell = "keyed")]
35pub struct EnvMap(#[bincode(with = "turbo_bincode::indexmap")] FxIndexMap<RcStr, RcStr>);
36
37/// An [`EnvMap`] with uppercased keys, used for key-granular case-insensitive lookups.
38///
39/// Unlike [`TransientEnvMap`] this is persisted: it only contains values that are already
40/// persisted in the [`EnvMap`] it's derived from. Keyed comparison needs the previous content, so
41/// persisting it keeps a dirty recomputation after a warm restore from invalidating every reader.
42#[turbo_tasks::value(transparent, cell = "keyed")]
43struct UppercaseEnvMap(#[bincode(with = "turbo_bincode::indexmap")] FxIndexMap<RcStr, RcStr>);
44
45#[turbo_tasks::function]
46async fn uppercase_env_map(map: Vc<EnvMap>) -> Result<Vc<UppercaseEnvMap>> {
47    let map = &*map.await?;
48    let mut new = FxIndexMap::with_capacity_and_hasher(map.len(), Default::default());
49    for (k, v) in map {
50        new.insert(k.to_uppercase().into(), v.clone());
51    }
52    Ok(Vc::cell(new))
53}
54
55#[turbo_tasks::value_impl]
56impl EnvMap {
57    #[turbo_tasks::function]
58    pub fn empty() -> Vc<Self> {
59        EnvMap(FxIndexMap::default()).cell()
60    }
61}
62
63#[turbo_tasks::value_impl]
64impl ProcessEnv for EnvMap {
65    #[turbo_tasks::function]
66    async fn read_all(self: Vc<Self>) -> Result<Vc<TransientEnvMap>> {
67        Ok(Vc::cell((*self.await?).clone()))
68    }
69
70    /// Reads a single env variable, ignoring casing. Only depends on the requested variable, so
71    /// it isn't invalidated when other variables change.
72    #[turbo_tasks::function]
73    async fn read(self: Vc<Self>, name: RcStr) -> Result<Vc<Option<RcStr>>> {
74        let value = uppercase_env_map(self)
75            .get(name.to_uppercase().as_str())
76            .await?;
77        Ok(Vc::cell(value.as_deref().cloned()))
78    }
79}
80
81#[turbo_tasks::value_trait]
82pub trait ProcessEnv {
83    /// Reads all env variables into a Map
84    #[turbo_tasks::function]
85    fn read_all(self: Vc<Self>) -> Vc<TransientEnvMap>;
86
87    /// Reads a single env variable. Ignores casing.
88    #[turbo_tasks::function]
89    fn read(self: Vc<Self>, name: RcStr) -> Vc<Option<RcStr>> {
90        case_insensitive_read(self.read_all(), name)
91    }
92}
93
94pub fn sorted_env_vars() -> FxIndexMap<RcStr, RcStr> {
95    let mut vars = env::vars()
96        .map(|(k, v)| (k.into(), v.into()))
97        .collect::<FxIndexMap<_, _>>();
98    vars.sort_keys();
99    vars
100}
101
102#[turbo_tasks::function]
103pub async fn case_insensitive_read(
104    map: Vc<TransientEnvMap>,
105    name: RcStr,
106) -> Result<Vc<Option<RcStr>>> {
107    Ok(Vc::cell(
108        to_uppercase_map(map)
109            .await?
110            .get(&RcStr::from(name.to_uppercase()))
111            .cloned(),
112    ))
113}
114
115#[turbo_tasks::function]
116async fn to_uppercase_map(map: Vc<TransientEnvMap>) -> Result<Vc<TransientEnvMap>> {
117    let map = &*map.await?;
118    let mut new = FxIndexMap::with_capacity_and_hasher(map.len(), Default::default());
119    for (k, v) in map {
120        new.insert(k.to_uppercase().into(), v.clone());
121    }
122    Ok(Vc::cell(new))
123}
124
125pub static GLOBAL_ENV_LOCK: Mutex<()> = Mutex::new(());