fix(enum): apply enum_value custom strings on Go server & client JSON (#214)

* fix(enum): apply enum_value custom strings on Go server & client JSON

The OpenAPI generator (and TS/Python clients) honor (sebuf.http.enum_value)
and emit "low"/"medium"/"high", but the generated Go HTTP server emitted the
raw proto names ("RISK_LEVEL_LOW"). Both Go surfaces serialize at the message
level with protojson, which never invokes the Go enum type's MarshalJSON — so
the enum-type marshalers in *_enum_encoding.pb.go are dead code server-side.

Add a message-level marshaler (*_enum_field_encoding.pb.go) for any message
with a custom-enum field. It reuses the existing xToJSON/xFromJSON lookup maps
to rewrite enum fields between proto value names and custom strings, in both
directions (MarshalJSONSebuf emits "low"; UnmarshalJSONSebuf accepts "low"),
across all shapes: singular, proto3 optional, repeated, and map<_, enum>.

Because a Go type can own only one MarshalJSON, register enum_value in the
existing fail-fast conflict web (flatten, oneof) plus a new
checkEnumMarshalJSONConflict, so combining a custom enum with another
JSON-mapping annotation errors clearly instead of emitting duplicate methods.

Mirrored in clientgen for Go-client request parity. Adds examples/enum-encoding
with an end-to-end test proving the wire format. Also regenerates the
TimestampFormat OpenAPI golden, which was already stale on current deps from a
recent protobuf bump (unrelated to this change).

Follow-ups tracked in #213 (transitive nesting, generator composition,
dual-plugin file collision, cross-package enums).

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* chore(lint): suppress dupl on generated enum marshaler helpers

golangci-lint flags the message-level marshaler/unmarshaler generators as
duplicates of the flatten/timestamp equivalents. Add //nolint:dupl where dupl
actually fires (matching the existing bytes_encoding.go convention), placed
asymmetrically to avoid an unused-directive nolintlint error.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* fix(enum): handle UseProtoNames keys and fail loudly on cross-package enums

Addresses Codex review feedback on the enum_value marshaler:

1. UseProtoNames regression: the patcher keyed only on the camelCase JSON name,
   so a server/client configured with protojson UseProtoNames (snake_case keys)
   left enum fields unpatched and leaked raw proto names. Marshal/unmarshal now
   patch both the JSON name and the proto name key.

2. Cross-package enums were silently skipped (silent wrong output). Generation
   now fails loudly via validateEnumFieldEncoding when a custom-enum field
   references an enum from another Go package, since the marshaler relies on that
   package's private lookup maps. Full cross-package support remains tracked in #213.

Adds a UseProtoNames end-to-end assertion to examples/enum-encoding and updates
the consistency test for the two-key patch shape.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

---------

Co-authored-by: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: SebastienMelki

examples/enum-encoding/Makefile

@@ -0,0 +1,38 @@
+.PHONY: test demo install generate run clean curl
+
+# Default: generate code and run the non-blocking end-to-end proof.
+test: generate
+	@go test ./...
+
+# Demo workflow - generates code, then starts the blocking server (Ctrl+C to stop).
+demo: generate run
+
+# Install required tools
+install:
+	@echo "Installing sebuf plugins..."
+	@go install github.com/bufbuild/buf/cmd/buf@latest
+	@go install google.golang.org/protobuf/cmd/protoc-gen-go@latest
+	@GOPROXY=direct go install github.com/SebastienMelki/sebuf/cmd/protoc-gen-go-http@latest
+	@echo "Tools installed"
+
+# Generate code from proto files (requires ../../bin plugins: run `make build` at repo root)
+generate:
+	@echo "Generating code..."
+	@buf generate
+	@go mod tidy
+	@echo "Code generated"
+
+# Run the server (blocks until Ctrl+C; hit it from another terminal with `make curl`)
+run:
+	@echo "Starting server on :8080 (Ctrl+C to stop). From another terminal: make curl"
+	@go run main.go
+
+# Hit the running server (start it with `make run` first)
+curl:
+	@curl -s localhost:8080/api/v1/suggestion -d '{"symbol":"AAPL","requestedRisk":"low"}'
+	@echo ""
+
+# Clean generated files
+clean:
+	@rm -rf api
+	@echo "Cleaned generated files"

examples/enum-encoding/README.md

@@ -0,0 +1,51 @@
+# enum-encoding
+
+Demonstrates the `(sebuf.http.enum_value)` annotation end-to-end on the generated
+Go HTTP server.
+
+The `RiskLevel` enum maps its values to custom JSON strings:
+
+```protobuf
+enum RiskLevel {
+  RISK_LEVEL_UNSPECIFIED = 0;                                  // no mapping -> proto name
+  RISK_LEVEL_LOW    = 1 [(sebuf.http.enum_value) = "low"];
+  RISK_LEVEL_MEDIUM = 2 [(sebuf.http.enum_value) = "medium"];
+  RISK_LEVEL_HIGH   = 3 [(sebuf.http.enum_value) = "high"];
+}
+```
+
+The generated server serializes responses and parses requests through `protojson`,
+which by itself emits the raw proto names (`RISK_LEVEL_LOW`). sebuf generates a
+message-level marshaler (`*_enum_field_encoding.pb.go`) that rewrites enum fields to
+their custom strings on the way out and back on the way in, so the wire format matches
+the OpenAPI docs and the TypeScript/Python clients.
+
+## What it proves
+
+`POST /api/v1/suggestion` with body `{"symbol":"AAPL","requestedRisk":"low"}` returns:
+
+```json
+{
+  "symbol": "AAPL",
+  "probabilityOfProfit": 0.62,
+  "riskLevel": "low",
+  "alternateRiskLevels": ["medium", "high"],
+  "riskBySymbol": {"AAPL": "low", "TSLA": "high"}
+}
+```
+
+- `"low"` in the request body is accepted (request parsing).
+- `riskLevel`, the repeated `alternateRiskLevels`, and the `riskBySymbol` map values
+  all serialize as custom strings — never `RISK_LEVEL_LOW`.
+
+## Run
+
+```bash
+# from the repo root, build the plugins first:
+make build
+
+cd examples/enum-encoding
+make generate      # buf generate + go mod tidy
+make test          # end-to-end assertion (main_test.go)
+make run           # start the server on :8080, then: make curl
+```