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#[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#[turbo_tasks::value(transparent, cell = "keyed")]
35pub struct EnvMap(#[bincode(with = "turbo_bincode::indexmap")] FxIndexMap<RcStr, RcStr>);
36
37#[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 #[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 #[turbo_tasks::function]
85 fn read_all(self: Vc<Self>) -> Vc<TransientEnvMap>;
86
87 #[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(());