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 {