Add store support for Spin adapter (KV, config, secret)

.github/workflows/test.yml

@@ -45,9 +45,6 @@ jobs:
       - name: Add wasm targets
         run: rustup target add wasm32-wasip1 wasm32-unknown-unknown
 
-      - name: Setup Viceroy
-        run: cargo install viceroy --locked --force
-
       - name: Fetch dependencies (locked)
         run: cargo fetch --locked
 
@@ -57,12 +54,25 @@ jobs:
       - name: Check feature compilation
         run: cargo check --workspace --all-targets --features "fastly cloudflare spin"
 
-      - name: Check Spin wasm32 compilation
-        run: cargo check -p edgezero-adapter-spin --target wasm32-wasip1 --features spin
-
-  cloudflare-wasm-tests:
-    name: cloudflare wasm tests
+  adapter-wasm-tests:
+    name: ${{ matrix.adapter }} wasm tests
     runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - adapter: cloudflare
+            target: wasm32-unknown-unknown
+            runner_env: CARGO_TARGET_WASM32_UNKNOWN_UNKNOWN_RUNNER
+            runner_value: wasm-bindgen-test-runner
+          - adapter: fastly
+            target: wasm32-wasip1
+            runner_env: CARGO_TARGET_WASM32_WASIP1_RUNNER
+            runner_value: viceroy run
+          - adapter: spin
+            target: wasm32-wasip1
+            runner_env: CARGO_TARGET_WASM32_WASIP1_RUNNER
+            runner_value: wasmtime run
     steps:
       - uses: actions/checkout@v4
 
@@ -73,25 +83,27 @@ jobs:
             ~/.cargo/registry/index/
             ~/.cargo/registry/cache/
             ~/.cargo/git/db/
+            ~/.wasmtime/bin/
             target/
-          key: ${{ runner.os }}-cargo-cloudflare-${{ hashFiles('**/Cargo.lock') }}
+          key: ${{ runner.os }}-cargo-${{ matrix.adapter }}-${{ hashFiles('**/Cargo.lock') }}
           restore-keys: |
-            ${{ runner.os }}-cargo-cloudflare-
+            ${{ runner.os }}-cargo-${{ matrix.adapter }}-
 
       - name: Retrieve Rust version
-        id: rust-version-cloudflare
+        id: rust-version
         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 }}
+          toolchain: ${{ steps.rust-version.outputs.rust-version }}
 
-      - name: Add wasm32 target
-        run: rustup target add wasm32-unknown-unknown
+      - name: Add wasm target
+        run: rustup target add ${{ matrix.target }}
 
       - name: Resolve wasm-bindgen CLI version
+        if: matrix.adapter == 'cloudflare'
         id: wasm-bindgen-version
         shell: bash
         run: |
@@ -109,60 +121,43 @@ jobs:
           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
+        if: matrix.adapter == 'cloudflare'
+        run: |
+          required="${{ steps.wasm-bindgen-version.outputs.version }}"
+          if ! command -v wasm-bindgen-test-runner &>/dev/null \
+              || ! wasm-bindgen --version 2>/dev/null | grep -q "$required"; then
+            cargo install wasm-bindgen-cli --version "$required" --locked --force
+          fi
 
-      - name: Run Cloudflare wasm tests
+      - name: Setup Viceroy
+        if: matrix.adapter == 'fastly'
         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
-
-      - name: Check Cloudflare wasm target
-        run: cargo check -p edgezero-adapter-cloudflare --features cloudflare --target wasm32-unknown-unknown
-
-  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/registry/index/
-            ~/.cargo/registry/cache/
-            ~/.cargo/git/db/
-            target/
-          key: ${{ runner.os }}-cargo-fastly-${{ hashFiles('**/Cargo.lock') }}
-          restore-keys: |
-            ${{ runner.os }}-cargo-fastly-
-
-      - 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 wasm targets
-        run: rustup target add wasm32-wasip1
+          VICEROY_VERSION: 0.16.5
+        run: |
+          if ! command -v viceroy &>/dev/null \
+              || ! viceroy --version 2>/dev/null | grep -qF "$VICEROY_VERSION"; then
+            cargo install viceroy --version "$VICEROY_VERSION" --locked
+          fi
 
-      - name: Setup Viceroy
-        run: cargo install viceroy --locked --force
+      - name: Setup Wasmtime
+        if: matrix.adapter == 'spin'
+        env:
+          WASMTIME_VERSION: v44.0.0
+        run: |
+          export PATH="$HOME/.wasmtime/bin:$PATH"
+          echo "$HOME/.wasmtime/bin" >> "$GITHUB_PATH"
+          if ! command -v wasmtime &>/dev/null \
+              || ! wasmtime --version 2>/dev/null | grep -qF "${WASMTIME_VERSION#v}"; then
+            curl https://wasmtime.dev/install.sh -sSf | bash -s -- --version "$WASMTIME_VERSION"
+          fi
 
       - name: Fetch dependencies (locked)
         run: cargo fetch --locked
 
-      - name: Run Fastly wasm tests
+      - name: Run ${{ matrix.adapter }} wasm tests
         env:
-          CARGO_TARGET_WASM32_WASIP1_RUNNER: "viceroy run"
-        run: cargo test -p edgezero-adapter-fastly --features fastly --target wasm32-wasip1 --test contract
+          ${{ matrix.runner_env }}: ${{ matrix.runner_value }}
+        run: cargo test -p edgezero-adapter-${{ matrix.adapter }} --features ${{ matrix.adapter }} --target ${{ matrix.target }} --test contract
 
-      - name: Check Fastly wasm target
-        run: cargo check -p edgezero-adapter-fastly --features fastly --target wasm32-wasip1
+      - name: Check ${{ matrix.adapter }} wasm target
+        run: cargo check -p edgezero-adapter-${{ matrix.adapter }} --features ${{ matrix.adapter }} --target ${{ matrix.target }}

.gitignore

@@ -6,6 +6,7 @@ bin/
 pkg/
 target/
 .wrangler/
+.spin/
 .edgezero/
 
 # env

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

@@ -0,0 +1,82 @@
+//! Spin adapter config store: wraps `spin_sdk::variables`.
+
+use edgezero_core::config_store::{ConfigStore, ConfigStoreError};
+
+/// Config store backed by Spin component variables.
+pub struct SpinConfigStore {
+    inner: SpinConfigBackend,
+}
+
+enum SpinConfigBackend {
+    #[cfg(all(feature = "spin", target_arch = "wasm32"))]
+    Spin,
+    #[cfg(test)]
+    InMemory(std::collections::HashMap<String, String>),
+    /// Never constructed; keeps the enum inhabited outside production Spin and tests.
+    #[cfg(not(any(all(feature = "spin", target_arch = "wasm32"), test)))]
+    _Uninhabited(std::convert::Infallible),
+}
+
+impl SpinConfigStore {
+    /// Create a new `SpinConfigStore` using the Spin variables API.
+    #[cfg(all(feature = "spin", target_arch = "wasm32"))]
+    pub fn new() -> Self {
+        Self {
+            inner: SpinConfigBackend::Spin,
+        }
+    }
+
+    #[cfg(test)]
+    fn from_entries(entries: impl IntoIterator<Item = (String, String)>) -> Self {
+        Self {
+            inner: SpinConfigBackend::InMemory(entries.into_iter().collect()),
+        }
+    }
+}
+
+#[cfg(all(feature = "spin", target_arch = "wasm32"))]
+impl Default for SpinConfigStore {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl ConfigStore for SpinConfigStore {
+    fn get(&self, _key: &str) -> Result<Option<String>, ConfigStoreError> {
+        match &self.inner {
+            #[cfg(all(feature = "spin", target_arch = "wasm32"))]
+            SpinConfigBackend::Spin => {
+                use spin_sdk::variables;
+                match variables::get(_key) {
+                    Ok(value) => Ok(Some(value)),
+                    Err(variables::Error::Undefined(_)) => Ok(None),
+                    Err(variables::Error::InvalidName(msg)) => {
+                        Err(ConfigStoreError::invalid_key(msg))
+                    }
+                    Err(e) => Err(ConfigStoreError::unavailable(e.to_string())),
+                }
+            }
+            #[cfg(test)]
+            SpinConfigBackend::InMemory(data) => Ok(data.get(_key).cloned()),
+            #[cfg(not(any(all(feature = "spin", target_arch = "wasm32"), test)))]
+            SpinConfigBackend::_Uninhabited(never) => match *never {},
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    // These contract tests exercise the InMemory backend (not the real Spin
+    // variables API). Dotted keys such as "contract.key.a" are valid here but
+    // would trigger `InvalidName` on the real Spin backend, which requires
+    // lowercase variable names without dots. Real-backend behaviour is
+    // verified by the smoke tests in scripts/smoke_test_config.sh.
+    edgezero_core::config_store_contract_tests!(spin_config_store_contract, {
+        SpinConfigStore::from_entries([
+            ("contract.key.a".to_string(), "value_a".to_string()),
+            ("contract.key.b".to_string(), "value_b".to_string()),
+        ])
+    });
+}

crates/edgezero-adapter-spin/src/key_value_store.rs

@@ -0,0 +1,107 @@
+//! Spin KV store adapter.
+//!
+//! Wraps `spin_sdk::key_value::Store` to implement the
+//! `edgezero_core::key_value_store::KvStore` trait.
+//!
+//! # Limitations
+//!
+//! - **TTL**: The Spin KV API has no TTL support. Calls to
+//!   `put_bytes_with_ttl` return `KvError::Validation` without writing.
+//! - **Listing**: `spin_sdk::key_value::Store::get_keys()` returns all keys
+//!   with no prefix or cursor support. `list_keys_page` therefore returns
+//!   `KvError::Validation` instead of materializing the whole store.
+//!
+//! # Note
+//!
+//! This module is only compiled when the `spin` feature is enabled and the
+//! target is `wasm32`.
+
+#[cfg(all(feature = "spin", target_arch = "wasm32"))]
+use async_trait::async_trait;
+#[cfg(all(feature = "spin", target_arch = "wasm32"))]
+use bytes::Bytes;
+#[cfg(all(feature = "spin", target_arch = "wasm32"))]
+use edgezero_core::key_value_store::{KvError, KvPage, KvStore};
+#[cfg(all(feature = "spin", target_arch = "wasm32"))]
+use std::time::Duration;
+
+/// KV store backed by the Spin KV API.
+///
+/// Wraps a `spin_sdk::key_value::Store` handle obtained via
+/// `Store::open(label)`.
+#[cfg(all(feature = "spin", target_arch = "wasm32"))]
+pub struct SpinKvStore {
+    store: spin_sdk::key_value::Store,
+}
+
+#[cfg(all(feature = "spin", target_arch = "wasm32"))]
+impl SpinKvStore {
+    /// Open a Spin KV store by label.
+    ///
+    /// The `label` must match a `key_value_stores` entry in `spin.toml`.
+    /// Returns `KvError::Internal` if the store cannot be opened.
+    pub fn open(label: &str) -> Result<Self, KvError> {
+        let store = spin_sdk::key_value::Store::open(label)
+            .map_err(|e| KvError::Internal(anyhow::anyhow!("failed to open kv store: {e}")))?;
+        Ok(Self { store })
+    }
+
+    /// Open the default EdgeZero KV store label (`"EDGEZERO_KV"`).
+    pub fn open_default() -> Result<Self, KvError> {
+        Self::open(edgezero_core::manifest::DEFAULT_KV_STORE_NAME)
+    }
+}
+
+#[cfg(all(feature = "spin", target_arch = "wasm32"))]
+#[async_trait(?Send)]
+impl KvStore for SpinKvStore {
+    async fn get_bytes(&self, key: &str) -> Result<Option<Bytes>, KvError> {
+        self.store
+            .get(key)
+            .map(|opt| opt.map(Bytes::from))
+            .map_err(|e| KvError::Internal(anyhow::anyhow!("get failed: {e}")))
+    }
+
+    async fn put_bytes(&self, key: &str, value: Bytes) -> Result<(), KvError> {
+        self.store
+            .set(key, value.as_ref())
+            .map_err(|e| KvError::Internal(anyhow::anyhow!("set failed: {e}")))
+    }
+
+    async fn put_bytes_with_ttl(
+        &self,
+        _key: &str,
+        _value: Bytes,
+        _ttl: Duration,
+    ) -> Result<(), KvError> {
+        Err(KvError::Validation(
+            "Spin KV does not support TTL; use put_bytes for non-expiring values".to_string(),
+        ))
+    }
+
+    async fn delete(&self, key: &str) -> Result<(), KvError> {
+        self.store
+            .delete(key)
+            .map_err(|e| KvError::Internal(anyhow::anyhow!("delete failed: {e}")))
+    }
+
+    async fn exists(&self, key: &str) -> Result<bool, KvError> {
+        self.store
+            .exists(key)
+            .map_err(|e| KvError::Internal(anyhow::anyhow!("exists failed: {e}")))
+    }
+
+    async fn list_keys_page(
+        &self,
+        _prefix: &str,
+        _cursor: Option<&str>,
+        _limit: usize,
+    ) -> Result<KvPage, KvError> {
+        Err(KvError::Validation(
+            "Spin KV key listing is unsupported because Store::get_keys() is unbounded".to_string(),
+        ))
+    }
+}
+
+// TODO: integration tests require the Spin runtime.
+// Test `SpinKvStore` as part of a Spin E2E test suite.