State<T> + nested/array #[secret] + Fastly dispatch fidelity + app! app-state injection

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

@@ -1,9 +1,12 @@
 //! Axum adapter config store: reads from a per-id local JSON file.
 //!
 //! Each declared `[stores.config].ids` id maps to a file at
-//! `.edgezero/local-config-<id>.json`. The file holds a flat object of
-//! `string -> string` pairs — the same shape `edgezero config push
-//! --adapter axum` writes.
+//! `.edgezero/local-config-<id>.json`. The file holds a JSON object of
+//! `string -> string` pairs. Typed `config push --adapter axum` writes ONE
+//! entry — the selected config key (defaults to the logical store id,
+//! overridable with `--key`) keyed to a JSON-encoded `BlobEnvelope` string,
+//! which the runtime `AppConfig<C>` extractor parses; hand-seeded flat
+//! key/value files also work for raw `get`.
 //!
 //! If the file is absent the store is empty (`get` returns `Ok(None)` for
 //! every key). This keeps `edgezero serve --adapter axum` permissive when
@@ -69,20 +72,21 @@ impl AxumConfigStore {
     /// by `config push --adapter axum` to a tempdir, without
     /// changing the process CWD.
     ///
-    /// The file must contain a flat JSON object of `string -> string`
-    /// pairs, matching what `config push --adapter axum` writes:
+    /// The file must be a JSON object of `string -> string` pairs.
+    /// Typed `config push --adapter axum` writes ONE entry — the selected
+    /// config key (defaults to the logical store id, overridable with
+    /// `--key`) keyed to a JSON-encoded `BlobEnvelope` string:
     ///
     /// ```json
     /// {
-    ///   "greeting": "hello",
-    ///   "feature.new_checkout": "false",
-    ///   "service.timeout_ms": "1500"
+    ///   "app_config": "{\"version\":1,\"generated_at\":\"…\",\"sha256\":\"…\",\"data\":{}}"
     /// }
     /// ```
     ///
-    /// Dotted keys are stored verbatim (no nesting): the runtime
-    /// extractors look up the dotted form as a single key. Non-string
-    /// values (`{"x": 42}`, nested objects, arrays) are rejected.
+    /// The runtime `AppConfig<C>` extractor parses that envelope string;
+    /// hand-seeded flat key/value files also work for raw `get`. Values
+    /// must be strings — non-string values (`{"x": 42}`, nested objects,
+    /// arrays) are rejected.
     ///
     /// Behaviour matches `from_local_file`: a missing file yields
     /// an empty store; a present-but-malformed file yields

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

@@ -340,7 +340,9 @@ pub fn run_app<A: Hooks>() -> anyhow::Result<()> {
         .and_then(|raw| LevelFilter::from_str(raw).ok())
         .unwrap_or(LevelFilter::Info);
 
-    let _logger_init = SimpleLogger::new().with_level(level).init();
+    if !A::owns_logging() {
+        let _logger_init = SimpleLogger::new().with_level(level).init();
+    }
 
     let resolution = resolve_addr(&env);
     for warning in &resolution.warnings {

crates/edgezero-adapter-cloudflare/src/lib.rs

@@ -101,8 +101,11 @@ pub async fn run_app<A: Hooks>(
     ctx: Context,
 ) -> Result<Response, WorkerError> {
     // Best-effort: if a logger is already installed, ignore the error rather
-    // than panicking — every Worker request re-enters this function.
-    drop(init_logger());
+    // than panicking — every Worker request re-enters this function. Skipped
+    // entirely when the app owns logging.
+    if !A::owns_logging() {
+        drop(init_logger());
+    }
     let stores = A::stores();
     let env_config = env_config_from_worker(&env, stores);
     let app = A::build_app();

crates/edgezero-adapter-fastly/src/lib.rs

@@ -25,6 +25,8 @@ use edgezero_core::app::{Hooks, StoresMetadata};
 #[cfg(feature = "fastly")]
 use edgezero_core::env_config::EnvConfig;
 #[cfg(feature = "fastly")]
+use edgezero_core::http::Extensions;
+#[cfg(feature = "fastly")]
 use edgezero_core::manifest::ResolvedLoggingConfig;
 #[cfg(feature = "fastly")]
 #[derive(Debug, Clone)]
@@ -111,15 +113,44 @@ fn logging_from_env(env: &EnvConfig) -> FastlyLogging {
 #[cfg(feature = "fastly")]
 #[inline]
 pub fn run_app<A: Hooks>(req: fastly::Request) -> Result<fastly::Response, fastly::Error> {
+    run_app_with_request_extensions::<A, _>(req, |_req, _extensions| {})
+}
+
+/// Like [`run_app`], but runs `extend` against a scratch
+/// [`Extensions`](edgezero_core::http::Extensions) populated from the raw
+/// `fastly::Request` (TLS JA4, H2 fingerprint, client IP, …) before the request
+/// is converted; the scratch values are merged into the core request's
+/// extensions and are visible to middleware and the `State`/extractor layer.
+///
+/// # Errors
+/// Returns an error if logger setup fails or any required store cannot be opened.
+#[cfg(feature = "fastly")]
+#[inline]
+pub fn run_app_with_request_extensions<A, F>(
+    req: fastly::Request,
+    extend: F,
+) -> Result<fastly::Response, fastly::Error>
+where
+    A: Hooks,
+    F: FnOnce(&fastly::Request, &mut Extensions),
+{
     let stores = A::stores();
     let env = env_config_from_runtime_dictionary(stores);
     let logging = logging_from_env(&env);
-    if logging.use_fastly_logger {
+    if logging.use_fastly_logger && !A::owns_logging() {
         let endpoint = logging.endpoint.as_deref().unwrap_or("stdout");
         init_logger(endpoint, logging.level, logging.echo_stdout)?;
     }
     let app = A::build_app();
-    request::dispatch_with_registries(&app, req, stores.config, stores.kv, stores.secrets, &env)
+    request::dispatch_with_registries(
+        &app,
+        req,
+        stores.config,
+        stores.kv,
+        stores.secrets,
+        &env,
+        extend,
+    )
 }
 
 /// Build an [`EnvConfig`] from the optional `edgezero_runtime_env`
@@ -202,7 +233,7 @@ pub fn run_app_with_config<A: Hooks>(
     req: fastly::Request,
     config_store_name: Option<&str>,
 ) -> Result<fastly::Response, fastly::Error> {
-    if logging.use_fastly_logger {
+    if logging.use_fastly_logger && !A::owns_logging() {
         let endpoint = logging.endpoint.as_deref().unwrap_or("stdout");
         init_logger(endpoint, logging.level, logging.echo_stdout)?;
     }

crates/edgezero-adapter-fastly/src/proxy.rs

@@ -46,15 +46,25 @@ fn build_fastly_request(method: Method, uri: &Uri, headers: &HeaderMap) -> Fastl
     let mut fastly_request = FastlyRequest::new(method.clone(), uri.to_string());
     fastly_request.set_method(method);
 
+    // Append (not set) so a multi-value client header survives; `Host` below is
+    // set explicitly as a single value.
     for (name, value) in headers {
         if name.as_str().eq_ignore_ascii_case("host") {
             continue;
         }
-        fastly_request.set_header(name.as_str(), value.clone());
+        fastly_request.append_header(name.as_str(), value.clone());
     }
 
+    // Build `Host` from host + explicit port so a non-default target port is
+    // preserved (origin-form fidelity) WITHOUT leaking any `user:pass@` userinfo
+    // that `uri.authority()` would include. (Backend connection + TLS SNI still
+    // key off `uri.host()` in `ensure_backend`.)
     if let Some(host) = uri.host() {
-        fastly_request.set_header("Host", host);
+        let value = match uri.port() {
+            Some(port) => format!("{host}:{}", port.as_str()),
+            None => host.to_owned(),
+        };
+        fastly_request.set_header("Host", value.as_str());
     }
 
     fastly_request
@@ -64,9 +74,13 @@ fn convert_response(fastly_response: &mut FastlyResponse) -> ProxyResponse {
     let status = fastly_response.get_status();
     let mut proxy_response = ProxyResponse::new(status, Body::empty());
 
-    for header in fastly_response.get_header_names() {
-        if let Some(value) = fastly_response.get_header(header) {
-            proxy_response.headers_mut().insert(header, value.clone());
+    // Preserve multi-value ORIGIN response headers (e.g. Set-Cookie): read ALL
+    // values per name and append, instead of first-value + insert (which
+    // replaced). `get_header_names()` yields `&HeaderName`, usable for both
+    // `get_header_all` and `append`.
+    for name in fastly_response.get_header_names() {
+        for value in fastly_response.get_header_all(name) {
+            proxy_response.headers_mut().append(name, value.clone());
         }
     }
 
@@ -212,6 +226,23 @@ mod tests {
         }
     }
 
+    #[test]
+    fn convert_response_preserves_multi_value_set_cookie() {
+        let mut fastly_response = FastlyResponse::from_status(200);
+        fastly_response.append_header("set-cookie", "a=1");
+        fastly_response.append_header("set-cookie", "b=2");
+
+        let proxy_response = convert_response(&mut fastly_response);
+
+        let cookies: Vec<String> = proxy_response
+            .headers()
+            .get_all("set-cookie")
+            .into_iter()
+            .map(|value| value.to_str().expect("utf8").to_owned())
+            .collect();
+        assert_eq!(cookies, vec!["a=1".to_owned(), "b=2".to_owned()]);
+    }
+
     #[test]
     fn stream_handles_brotli() {
         let mut compressed = Vec::new();

crates/edgezero-adapter-fastly/src/request.rs

@@ -8,7 +8,7 @@ use edgezero_core::body::Body;
 use edgezero_core::config_store::ConfigStoreHandle;
 use edgezero_core::env_config::EnvConfig;
 use edgezero_core::error::EdgeError;
-use edgezero_core::http::{request_builder, Request};
+use edgezero_core::http::{request_builder, Extensions, Request};
 use edgezero_core::key_value_store::KvHandle;
 use edgezero_core::proxy::ProxyHandle;
 use edgezero_core::secret_store::SecretHandle;
@@ -151,6 +151,7 @@ impl<'app> FastlyService<'app> {
                 secrets,
                 ..Default::default()
             },
+            |_req, _extensions| {},
         )
     }
 
@@ -276,12 +277,31 @@ fn dispatch_core_request(
     from_core_response(response).map_err(|err| map_edge_error(&err))
 }
 
-fn dispatch_with_handles(
+/// Run an app-provided closure against a scratch `Extensions` populated from the
+/// RAW `fastly::Request` (JA4 / H2 / etc.), BEFORE `into_core_request` consumes
+/// the request. Returns the scratch bag to be `extend`ed into the core request.
+fn apply_request_extend<F>(req: &FastlyRequest, extend: F) -> Extensions
+where
+    F: FnOnce(&FastlyRequest, &mut Extensions),
+{
+    let mut scratch = Extensions::default();
+    extend(req, &mut scratch);
+    scratch
+}
+
+fn dispatch_with_handles<F>(
     app: &App,
     req: FastlyRequest,
     stores: Stores,
-) -> Result<FastlyResponse, FastlyError> {
-    let core_request = into_core_request(req).map_err(|err| map_edge_error(&err))?;
+    extend: F,
+) -> Result<FastlyResponse, FastlyError>
+where
+    F: FnOnce(&FastlyRequest, &mut Extensions),
+{
+    // Read raw-request signals into a scratch bag BEFORE conversion consumes `req`.
+    let scratch = apply_request_extend(&req, extend);
+    let mut core_request = into_core_request(req).map_err(|err| map_edge_error(&err))?;
+    core_request.extensions_mut().extend(scratch);
     dispatch_core_request(app, core_request, stores)
 }
 
@@ -292,14 +312,18 @@ fn dispatch_with_handles(
 /// id default). KV failures escalate via [`resolve_kv_handle`]'s
 /// `kv_required=true` path; missing config / secret stores degrade silently
 /// with a one-time warning.
-pub(crate) fn dispatch_with_registries(
+pub(crate) fn dispatch_with_registries<F>(
     app: &App,
     req: FastlyRequest,
     config_meta: Option<StoreMetadata>,
     kv_meta: Option<StoreMetadata>,
     secret_meta: Option<StoreMetadata>,
     env: &EnvConfig,
-) -> Result<FastlyResponse, FastlyError> {
+    extend: F,
+) -> Result<FastlyResponse, FastlyError>
+where
+    F: FnOnce(&FastlyRequest, &mut Extensions),
+{
     let kv_registry = build_kv_registry(kv_meta, env)?;
     let config_registry = build_config_registry(config_meta, env);
     let secret_registry = build_secret_registry(secret_meta, env);
@@ -312,6 +336,7 @@ pub(crate) fn dispatch_with_registries(
             secret_registry,
             ..Default::default()
         },
+        extend,
     )
 }
 
@@ -573,6 +598,65 @@ mod synthesis_tests {
         SecretHandle::new(Arc::new(NoopSecretStore))
     }
 
+    #[test]
+    fn apply_request_extend_populates_scratch_from_raw_request() {
+        use edgezero_core::http::Method;
+
+        #[derive(Clone, Debug, PartialEq)]
+        struct Ja4(String);
+
+        let raw = FastlyRequest::new(Method::GET, "http://example.test/");
+        let scratch = apply_request_extend(&raw, |req, extensions| {
+            // A real closure would call req.get_tls_ja4(); deriving from the URL
+            // keeps the assertion deterministic under Viceroy.
+            let marker = req.get_url_str().to_owned();
+            extensions.insert(Ja4(marker));
+        });
+
+        assert_eq!(
+            scratch.get::<Ja4>(),
+            Some(&Ja4("http://example.test/".to_owned()))
+        );
+    }
+
+    #[test]
+    fn extended_request_extensions_are_visible_to_handler() {
+        use edgezero_core::body::Body;
+        use edgezero_core::context::RequestContext;
+        use edgezero_core::http::{request_builder, Method, StatusCode};
+        use edgezero_core::router::RouterService;
+        use futures::executor::block_on;
+
+        #[derive(Clone)]
+        struct Ja4(String);
+
+        async fn handler(ctx: RequestContext) -> Result<String, EdgeError> {
+            let ja4 = ctx
+                .request()
+                .extensions()
+                .get::<Ja4>()
+                .map_or_else(|| "missing".to_owned(), |value| value.0.clone());
+            Ok(ja4)
+        }
+
+        // Mirror what `dispatch_with_handles` does: a scratch bag built from the
+        // raw request is `extend`ed into the core request before dispatch.
+        let mut scratch = Extensions::default();
+        scratch.insert(Ja4("t13d1516h2".to_owned()));
+
+        let mut core_request = request_builder()
+            .method(Method::GET)
+            .uri("/ja4")
+            .body(Body::empty())
+            .expect("request");
+        core_request.extensions_mut().extend(scratch);
+
+        let service = RouterService::builder().get("/ja4", handler).build();
+        let response = block_on(service.oneshot(core_request)).expect("response");
+        assert_eq!(response.status(), StatusCode::OK);
+        assert_eq!(response.body().as_bytes().expect("buffered"), b"t13d1516h2");
+    }
+
     #[test]
     fn synthesis_wraps_bare_kv_handle_under_default_when_no_registry() {
         let stores = Stores {