Add config store support across all adapters

.github/workflows/test.yml

@@ -57,3 +57,106 @@ jobs:
 
       - name: Check feature compilation
         run: cargo check --workspace --all-targets --features "fastly cloudflare"
+
+  cloudflare-wasm-tests:
+    name: cloudflare wasm tests
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Cache Cargo dependencies
+        uses: actions/cache@v4
+        with:
+          path: |
+            ~/.cargo/bin/
+            ~/.cargo/registry/index/
+            ~/.cargo/registry/cache/
+            ~/.cargo/git/db/
+            target/
+          key: ${{ runner.os }}-cargo-${{ hashFiles('**/Cargo.lock') }}
+          restore-keys: |
+            ${{ runner.os }}-cargo-
+
+      - name: Retrieve Rust version
+        id: rust-version-cloudflare
+        run: echo "rust-version=$(grep '^rust ' .tool-versions | awk '{print $2}')" >> $GITHUB_OUTPUT
+        shell: bash
+
+      - name: Set up Rust tool chain
+        uses: actions-rust-lang/setup-rust-toolchain@v1
+        with:
+          toolchain: ${{ steps.rust-version-cloudflare.outputs.rust-version }}
+
+      - name: Add wasm32 target
+        run: rustup target add wasm32-unknown-unknown
+
+      - name: Resolve wasm-bindgen CLI version
+        id: wasm-bindgen-version
+        shell: bash
+        run: |
+          version="$(
+            awk '
+              $1 == "name" && $3 == "\"wasm-bindgen\"" { in_pkg=1; next }
+              in_pkg && $1 == "version" {
+                gsub(/"/, "", $3)
+                print $3
+                exit
+              }
+            ' Cargo.lock
+          )"
+          test -n "$version"
+          echo "version=$version" >> "$GITHUB_OUTPUT"
+
+      - name: Install wasm-bindgen test runner
+        run: cargo install wasm-bindgen-cli --version "${{ steps.wasm-bindgen-version.outputs.version }}" --locked --force
+
+      - name: Fetch dependencies (locked)
+        run: cargo fetch --locked
+
+      - name: Run Cloudflare wasm tests
+        env:
+          CARGO_TARGET_WASM32_UNKNOWN_UNKNOWN_RUNNER: wasm-bindgen-test-runner
+        run: cargo test -p edgezero-adapter-cloudflare --features cloudflare --target wasm32-unknown-unknown --test contract
+
+  fastly-wasm-tests:
+    name: fastly wasm tests
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Cache Cargo dependencies
+        uses: actions/cache@v4
+        with:
+          path: |
+            ~/.cargo/bin/
+            ~/.cargo/registry/index/
+            ~/.cargo/registry/cache/
+            ~/.cargo/git/db/
+            target/
+          key: ${{ runner.os }}-cargo-${{ hashFiles('**/Cargo.lock') }}
+          restore-keys: |
+            ${{ runner.os }}-cargo-
+
+      - name: Retrieve Rust version
+        id: rust-version-fastly
+        run: echo "rust-version=$(grep '^rust ' .tool-versions | awk '{print $2}')" >> $GITHUB_OUTPUT
+        shell: bash
+
+      - name: Set up Rust tool chain
+        uses: actions-rust-lang/setup-rust-toolchain@v1
+        with:
+          toolchain: ${{ steps.rust-version-fastly.outputs.rust-version }}
+
+      - name: Add wasm32-wasi target
+        run: rustup target add wasm32-wasip1
+
+      - name: Setup Viceroy
+        run: cargo install viceroy --locked
+
+      - name: Fetch dependencies (locked)
+        run: cargo fetch --locked
+
+      - name: Run Fastly wasm tests
+        env:
+          CARGO_TARGET_WASM32_WASIP1_RUNNER: "viceroy run"
+        run: cargo test -p edgezero-adapter-fastly --features fastly --target wasm32-wasip1 --test contract

.gitignore

@@ -4,6 +4,9 @@ pkg/
 target/
 .wrangler/
 
+# Node
+node_modules/
+
 # env
 .env
 

crates/edgezero-adapter-axum/src/config_store.rs

@@ -0,0 +1,154 @@
+//! Axum adapter config store: env vars with in-memory defaults fallback.
+
+use std::collections::HashMap;
+
+use edgezero_core::config_store::{ConfigStore, ConfigStoreError};
+
+/// Config store for local dev / Axum. Reads from env vars with manifest
+/// defaults as fallback. Env vars take precedence over defaults.
+///
+/// # Note on `from_env`
+///
+/// [`AxumConfigStore::from_env`] only reads environment variables for keys
+/// declared in `[stores.config.defaults]`. Use an empty-string default when a
+/// key should be overrideable from env without carrying a real default value.
+pub struct AxumConfigStore {
+    env: HashMap<String, String>,
+    defaults: HashMap<String, String>,
+}
+
+impl AxumConfigStore {
+    /// Create from env vars and optional manifest defaults.
+    pub fn new(
+        env: impl IntoIterator<Item = (String, String)>,
+        defaults: impl IntoIterator<Item = (String, String)>,
+    ) -> Self {
+        Self {
+            env: env.into_iter().collect(),
+            defaults: defaults.into_iter().collect(),
+        }
+    }
+
+    /// Create from the current process environment and manifest defaults.
+    pub fn from_env(defaults: impl IntoIterator<Item = (String, String)>) -> Self {
+        Self::from_lookup(defaults, |key| std::env::var(key).ok())
+    }
+
+    fn from_lookup<F>(defaults: impl IntoIterator<Item = (String, String)>, mut lookup: F) -> Self
+    where
+        F: FnMut(&str) -> Option<String>,
+    {
+        let defaults: HashMap<String, String> = defaults.into_iter().collect();
+        let env = defaults
+            .keys()
+            .filter_map(|key| lookup(key).map(|value| (key.clone(), value)))
+            .collect();
+        Self { env, defaults }
+    }
+}
+
+impl ConfigStore for AxumConfigStore {
+    fn get(&self, key: &str) -> Result<Option<String>, ConfigStoreError> {
+        Ok(self
+            .env
+            .get(key)
+            .or_else(|| self.defaults.get(key))
+            .cloned())
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn store(env: &[(&str, &str)], defaults: &[(&str, &str)]) -> AxumConfigStore {
+        AxumConfigStore::new(
+            env.iter().map(|(k, v)| (k.to_string(), v.to_string())),
+            defaults.iter().map(|(k, v)| (k.to_string(), v.to_string())),
+        )
+    }
+
+    #[test]
+    fn axum_config_store_returns_values() {
+        let s = store(&[("MY_KEY", "my_val")], &[]);
+        assert_eq!(
+            s.get("MY_KEY").expect("config value"),
+            Some("my_val".to_string())
+        );
+    }
+
+    #[test]
+    fn axum_config_store_returns_none_for_missing() {
+        let s = store(&[], &[]);
+        assert_eq!(s.get("NOPE").expect("missing config"), None);
+    }
+
+    #[test]
+    fn axum_config_store_env_overrides_defaults() {
+        let s = store(&[("KEY", "from_env")], &[("KEY", "from_default")]);
+        assert_eq!(
+            s.get("KEY").expect("config value"),
+            Some("from_env".to_string())
+        );
+    }
+
+    #[test]
+    fn axum_config_store_falls_back_to_defaults() {
+        let s = store(&[], &[("KEY", "default_val")]);
+        assert_eq!(
+            s.get("KEY").expect("default config"),
+            Some("default_val".to_string())
+        );
+    }
+
+    #[test]
+    fn axum_config_store_from_env_reads_only_declared_keys() {
+        let s = AxumConfigStore::from_lookup(
+            [
+                ("feature.new_checkout".to_string(), "false".to_string()),
+                ("service.timeout_ms".to_string(), "1500".to_string()),
+            ],
+            |key| match key {
+                "feature.new_checkout" => Some("true".to_string()),
+                "DATABASE_URL" => Some("postgres://secret".to_string()),
+                _ => None,
+            },
+        );
+
+        assert_eq!(
+            s.get("feature.new_checkout").expect("allowed env override"),
+            Some("true".to_string())
+        );
+        assert_eq!(
+            s.get("service.timeout_ms").expect("default fallback"),
+            Some("1500".to_string())
+        );
+        assert_eq!(
+            s.get("DATABASE_URL")
+                .expect("undeclared key should stay hidden"),
+            None
+        );
+    }
+
+    // Run the shared contract tests against AxumConfigStore (env path).
+    edgezero_core::config_store_contract_tests!(axum_config_store_env_contract, {
+        AxumConfigStore::new(
+            [
+                ("contract.key.a".to_string(), "value_a".to_string()),
+                ("contract.key.b".to_string(), "value_b".to_string()),
+            ],
+            [],
+        )
+    });
+
+    // Run the shared contract tests against AxumConfigStore (defaults path).
+    edgezero_core::config_store_contract_tests!(axum_config_store_defaults_contract, {
+        AxumConfigStore::new(
+            [],
+            [
+                ("contract.key.a".to_string(), "value_a".to_string()),
+                ("contract.key.b".to_string(), "value_b".to_string()),
+            ],
+        )
+    });
+}

crates/edgezero-adapter-axum/src/dev_server.rs

@@ -7,11 +7,13 @@ use tokio::signal;
 use tower::{service_fn, Service};
 
 use edgezero_core::app::Hooks;
+use edgezero_core::config_store::ConfigStoreHandle;
 use edgezero_core::manifest::ManifestLoader;
 use edgezero_core::router::RouterService;
 use log::LevelFilter;
 use simple_logger::SimpleLogger;
 
+use crate::config_store::AxumConfigStore;
 use crate::service::EdgeZeroAxumService;
 
 /// Configuration used when running the dev server embedding EdgeZero into Axum.
@@ -34,18 +36,30 @@ impl Default for AxumDevServerConfig {
 pub struct AxumDevServer {
     router: RouterService,
     config: AxumDevServerConfig,
+    config_store_handle: Option<ConfigStoreHandle>,
 }
 
 impl AxumDevServer {
     pub fn new(router: RouterService) -> Self {
         Self {
             router,
             config: AxumDevServerConfig::default(),
+            config_store_handle: None,
         }
     }
 
     pub fn with_config(router: RouterService, config: AxumDevServerConfig) -> Self {
-        Self { router, config }
+        Self {
+            router,
+            config,
+            config_store_handle: None,
+        }
+    }
+
+    #[must_use]
+    pub fn with_config_store(mut self, handle: ConfigStoreHandle) -> Self {
+        self.config_store_handle = Some(handle);
+        self
     }
 
     pub fn run(self) -> anyhow::Result<()> {
@@ -58,7 +72,11 @@ impl AxumDevServer {
     }
 
     async fn run_async(self) -> anyhow::Result<()> {
-        let AxumDevServer { router, config } = self;
+        let AxumDevServer {
+            router,
+            config,
+            config_store_handle,
+        } = self;
 
         // Allow binding to already-open listener if caller created one to surface errors early.
         let listener = StdTcpListener::bind(config.addr)
@@ -70,22 +88,30 @@ impl AxumDevServer {
         let listener = tokio::net::TcpListener::from_std(listener)
             .context("failed to adopt std listener into tokio")?;
 
-        serve_with_listener(router, listener, config.enable_ctrl_c).await
+        serve_with_listener(router, listener, config.enable_ctrl_c, config_store_handle).await
     }
 
     #[cfg(test)]
     async fn run_with_listener(self, listener: tokio::net::TcpListener) -> anyhow::Result<()> {
-        let AxumDevServer { router, config } = self;
-        serve_with_listener(router, listener, config.enable_ctrl_c).await
+        let AxumDevServer {
+            router,
+            config,
+            config_store_handle,
+        } = self;
+        serve_with_listener(router, listener, config.enable_ctrl_c, config_store_handle).await
     }
 }
 
 async fn serve_with_listener(
     router: RouterService,
     listener: tokio::net::TcpListener,
     enable_ctrl_c: bool,
+    config_store_handle: Option<ConfigStoreHandle>,
 ) -> anyhow::Result<()> {
-    let service = EdgeZeroAxumService::new(router);
+    let mut service = EdgeZeroAxumService::new(router);
+    if let Some(handle) = config_store_handle {
+        service = service.with_config_store_handle(handle);
+    }
     let router = Router::new().fallback_service(service_fn(move |req| {
         let mut svc = service.clone();
         async move { svc.call(req).await }
@@ -113,7 +139,8 @@ async fn serve_with_listener(
 
 pub fn run_app<A: Hooks>(manifest_src: &str) -> anyhow::Result<()> {
     let manifest = ManifestLoader::load_from_str(manifest_src);
-    let logging = manifest.manifest().logging_or_default("axum");
+    let m = manifest.manifest();
+    let logging = m.logging_or_default(edgezero_core::app::AXUM_ADAPTER);
 
     let level: LevelFilter = logging.level.into();
     let level = if logging.echo_stdout.unwrap_or(true) {
@@ -127,7 +154,13 @@ pub fn run_app<A: Hooks>(manifest_src: &str) -> anyhow::Result<()> {
     let app = A::build_app();
     let router = app.router().clone();
 
-    AxumDevServer::new(router).run()
+    let mut server = AxumDevServer::new(router);
+    if let Some(cfg) = m.stores.config.as_ref() {
+        let defaults = cfg.config_store_defaults().clone();
+        let store = AxumConfigStore::from_env(defaults);
+        server = server.with_config_store(ConfigStoreHandle::new(std::sync::Arc::new(store)));
+    }
+    server.run()
 }
 
 #[cfg(test)]