feat(gateway): gzip injected HTML and cache when no SENSITIVE vars

[olamide226]

Summary

Two transport-layer optimisations for the inject middleware. Both apply across embedded and proxy modes; spec is unchanged.

REP-RFC-0001 §4.3 line 203 already permits caching when no REP_SENSITIVE_* variables are present. Gzip is wire-level transport encoding — the post-decode bytes are byte-identical to the injected bytes, so line 202's "MUST NOT modify any other part of the HTML response" still holds.

What changed

1. Re-compress after injection (gateway/internal/inject/inject.go)

The middleware previously stripped Accept-Encoding so the upstream would return identity (necessary for the </head> byte search) and then shipped the injected body uncompressed to the client. For gateways sitting in front of a static-site upstream, HTML was transferring at ~3–4× the size the upstream would have served natively.

Now: save the client's Accept-Encoding before stripping, gzip the final body when both:

• body is ≥ compressMinBytes (1 KB; below that gzip overhead exceeds savings), and
• client accepts gzip (parser honours q=0 rejections and the * wildcard).

Always sets Vary: Accept-Encoding on HTML responses so downstream caches don't serve the wrong encoding to a subsequent client.

2. In-memory cache of injected output

New Middleware.EnableCache() opts in to a per-path cache storing the processed identity body plus a pre-computed gzipped variant. Cache hits skip the upstream call entirely and serve the matching variant based on the client's Accept-Encoding.

Behaviour	Why
Disabled by default	Backwards-compat; existing callers see identical behaviour
EnableCache() is the only way to turn it on	Forces explicit, audit-friendly opt-in
Server enables only when !cfg.HotReload && len(vars.Sensitive) == 0	Honours §4.3 line 203
Skipped on non-GET, non-200, or any Set-Cookie upstream header	Don't cache per-user response data
Bounded at 1000 entries (drops new additions when full)	Generous for static-site workloads; protects against a runaway URL space
UpdateScriptTag clears the cache	Script changed → entries stale

Server wiring (gateway/internal/server/server.go)

s.injector = inject.New(upstream, scriptTag, logger)

if !cfg.HotReload && len(vars.Sensitive) == 0 {
    s.injector.EnableCache()
    logger.Info("rep.inject.cache_enabled", ...)
}

That's the entire delta in server.go.

Tests

gateway/internal/inject/inject_perf_test.go — 12 new cases, all passing:

• Compression: GzipEncodingWhenAccepted, NoGzipWhenClientDoesNotAccept, NoGzipForSmallBodies, GzipQZeroRejection
• Cache behaviour: CacheDisabledByDefault, CacheHitSkipsUpstream, CacheHitRespectsAcceptEncoding, UpdateScriptTagInvalidatesCache
• Cache safety: CacheSkipsSetCookieResponses, CacheSkipsNon200
• Headers: VaryHeaderPresent
• Parser: AcceptsGzip (table-driven coverage of q=0, wildcards, and the empty-header case)

go test ./...
ok  ./internal/config         0.309s
ok  ./internal/crypto         1.054s
ok  ./internal/guardrails     0.500s
ok  ./internal/health         0.778s
ok  ./internal/hotreload      1.320s
ok  ./internal/inject         1.934s
ok  ./internal/manifest       1.579s
ok  ./internal/server         1.774s
ok  ./pkg/payload             2.184s

All existing tests still pass — the only behavioural change for callers that don't opt into caching is that HTML responses now ship gzipped + with Vary: Accept-Encoding.

End-to-end smoke test

Built the binary, served a real ~20 KB SPA index.html in embedded mode with public-only env. Results:

$ curl -sD- -o /dev/null -H "Accept-Encoding: gzip" http://localhost:3737/dashboard/
HTTP/1.1 200 OK
Content-Encoding: gzip
Content-Length: 4186
Content-Type: text/html; charset=utf-8
Vary: Accept-Encoding

$ curl -sD- -o /dev/null http://localhost:3737/dashboard/
HTTP/1.1 200 OK
Content-Length: 20828
Content-Type: text/html; charset=utf-8
Vary: Accept-Encoding

• Identity body 20,828 bytes → gzipped 4,186 bytes (~80% reduction).
• Decompressed gzip response is byte-identical to identity response.
• Cache log on three repeat hits to the same path:
  • request 1 → rep.inject.html path=/dashboard/ original_size=20243 injected_size=20828
  • request 2 → rep.inject.cache_hit path=/dashboard/
  • request 3 → rep.inject.cache_hit path=/dashboard/

Test plan

• go test ./... — all 9 packages pass
• go vet ./... — clean
• Smoke: Content-Encoding: gzip and Vary: Accept-Encoding appear on HTML responses when client accepts gzip
• Smoke: identity response when client doesn't send Accept-Encoding
• Smoke: cache hits served without invoking the upstream

Out of scope

• Streaming response (still buffers full upstream body before injection — see RFC §4.3 byte-search requirement). Could be revisited with a streaming HTML scanner later.
• Persistent / disk cache for cold-start scenarios. Static-site workloads recover from a cold cache in one request per route, so this isn't urgent.
• Compression of non-HTML responses. Out of scope for the inject middleware; upstream servers typically handle those already.

[Copilot]

Pull request overview

This PR optimizes the gateway’s HTML injection middleware by re-compressing injected HTML responses (gzip when appropriate) and adding an optional in-memory cache of injected output for safe, static scenarios (no SENSITIVE vars + hot-reload disabled).

Changes:

• Re-compress injected HTML responses (gzip when client accepts and body is large enough) and add Vary: Accept-Encoding.
• Add an opt-in in-memory per-path cache for injected HTML with precomputed identity+gzip variants, plus invalidation on script tag updates.
• Wire cache enablement in the server when !cfg.HotReload && len(vars.Sensitive)==0, and add new tests covering compression, caching, and header behavior.

Reviewed changes

Copilot reviewed 3 out of 3 changed files in this pull request and generated 4 comments.

File	Description
gateway/internal/inject/inject.go	Adds gzip recompression after injection, Vary handling, and an opt-in bounded in-memory cache for processed HTML responses.
gateway/internal/server/server.go	Enables the inject cache automatically when hot-reload is off and there are no sensitive vars.
gateway/internal/inject/inject_perf_test.go	Adds tests for gzip negotiation, cache behavior/safety, and header expectations.

---

💡 Add Copilot custom instructions for smarter, more guided reviews. Learn how to get started.

[Copilot]

Pull request overview

Adds transport-level optimizations to the HTML injection middleware by re-introducing gzip to clients after injection and optionally caching injected HTML responses in-memory when the gateway is configured without sensitive variables.

Changes:

• Re-compress injected HTML with gzip when the client accepts it and the body is large enough; add Vary: Accept-Encoding.
• Add an opt-in in-memory cache in the inject middleware to skip upstream calls for repeated GETs.
• Wire cache enablement in the server when !cfg.HotReload && len(vars.Sensitive) == 0.

Reviewed changes

Copilot reviewed 3 out of 3 changed files in this pull request and generated 5 comments.

File	Description
gateway/internal/server/server.go	Enables inject middleware caching under “safe” configuration conditions.
gateway/internal/inject/inject.go	Implements gzip re-compression, Vary handling, and a per-path in-memory cache.
gateway/internal/inject/inject_perf_test.go	Adds test coverage for gzip negotiation, cache behavior, and header handling.

---

💡 Add Copilot custom instructions for smarter, more guided reviews. Learn how to get started.