codec

type Codec ¶

type Codec interface {
	// Name returns the Smithy protocol shape ID, e.g. NameAWSJSON10.
	// Used for diagnostics, logging, and the Smithy-Protocol response
	// header (Smithy RPC v2 protocols only).
	Name() string

	// Decode reads r.Body into into. into MUST be a non-nil pointer to a
	// typed input struct. Returns a *protocol.AWSError populated with a
	// 4xx code on malformed input, or nil on success.
	//
	// Decode is responsible for draining and closing r.Body so the
	// HTTP/1.1 connection can be reused. Callers MUST NOT touch r.Body
	// after calling Decode.
	Decode(r *http.Request, into any) *protocol.AWSError

	// WriteResponse serialises v as a successful response body using the
	// codec's native format and writes it to w with status. v may be nil
	// or a typed pointer; nil is rendered as the codec's empty-response
	// representation (e.g. "{}" for JSON).
	WriteResponse(w http.ResponseWriter, r *http.Request, status int, v any)

	// WriteError serialises aerr in the codec's native error envelope.
	// The HTTP status comes from aerr.HTTPStatus.
	WriteError(w http.ResponseWriter, r *http.Request, aerr *protocol.AWSError)
}

Codec serialises requests and responses for one AWS wire protocol.

Implementations MUST be stateless and safe for concurrent use. They never inspect the operation name, never know which service they're serving, and never invoke business logic.

Methods on Codec are intentionally narrow:

• Decode reads the request body into a pointer-to-struct.
• WriteResponse serialises a successful response.
• WriteError serialises an AWSError in the codec's native envelope.

All concrete codecs in Phase 0 are thin wrappers over the existing helpers in package protocol; the wire bytes are byte-identical.

var JSON10 Codec = json10{}

var JSON11 Codec = json11{}

var QueryXML Codec = queryXML{}

var RESTXML Codec = restXML{}

var RPCv2CBOR Codec = rpcv2CBOR{}

var RPCv2JSON Codec = rpcv2JSON{}

func FromContext(ctx context.Context) (Codec, string)

type Identifier ¶

type Identifier interface {
	// Claim returns (codec, operationName, true) on a match, or
	// (nil, "", false) if the request does not match this protocol.
	Claim(r *http.Request) (Codec, string, bool)
}

Identifier inspects a request and, if it matches the protocol's identification rules, returns the matching Codec and the AWS operation name encoded in the request.

Identifiers generally MUST NOT consume the request body — only headers, method, path, and (for query-protocol form bodies) the URL query string. Body consumption belongs to the codec's Decode pass.

identifyQuery is the sole, documented exception: the AWS Query protocol encodes Action into the POST body for the overwhelming majority of real SDK traffic, so resolving an operation name at all requires reading the body. It reads it through protocol.ParseFormPreservingBody, which caches the fields on r.Form — every later read of Action/other fields, whether by the router's own QueryDispatcher resolution, a legacy handler's r.FormValue calls, or the typed codec's Decode pass, reuses that cached r.Form — and puts the bytes back on r.Body so a request that only *looked* like Query traffic still reaches its own handler with its payload. Identifiers run ahead of routing, so "this content type means Query" is a guess, and a wrong guess must not cost the request its body. See docs/plans/level2-codegen.md Track 1.1.

The order in which identifiers are tried matters; see the Smithy AWS service protocol precision rules: https://smithy.io/2.0/guides/wire-protocol-selection.html#aws-service-protocol-precision

func DefaultIdentifiers() []Identifier