server

type ErrorRenderer func(c *gin.Context, err error)

type GRPCOption func(*GRPCServer)

type GRPCServer struct {
	// contains filtered or unexported fields
}

type HTTPOption func(*HTTPServer)

type HTTPRoute interface {
	// Name is a stable identifier for the route module.
	Name() string
	// RouteGroups returns the module's declarative route groups.
	RouteGroups() []*RouteGroup
}

type HTTPServer struct {
	// contains filtered or unexported fields
}

type MeshServer struct {
	// contains filtered or unexported fields
}

type MeshServerOption func(*MeshServer)

type Method struct {
	// Name is the gRPC method name, e.g. "SayHello".
	Name string
	// Method is the HTTP verb, e.g. "GET".
	Method string
	// Path is the HTTP path template, e.g. "/helloworld/{name}".
	Path string
	// Body is the body binding: "*" for the whole message, "" for none.
	Body string
	// Status is the HTTP status a successful call returns. Zero means 200, so a
	// Method built by NewMethod needs nothing set and existing generated code is
	// unaffected.
	//
	// It exists because the status is not derivable from the verb. A contract that
	// returns 201 for resource creation and 204 for deletion cannot be served by a
	// fixed 200: the two are told apart by what the operation *means*, not by
	// whether it is a POST. Set it from the contract, in the composition root,
	// where the contract is already being read.
	Status int

	// Handler is the unified business logic, shared with gRPC.
	Handler middleware.Handler
	// Render renders a successful (non-nil) response. Nil means codec.Render,
	// the framework's generic JSON/protobuf codec.
	//
	// It exists because the wire shape of a response is a decision the contract
	// owns, not the transport. The generic codec marshals the generated Go struct
	// with encoding/json, which drops zero-valued fields and emits a
	// google.protobuf.Timestamp as {"seconds":...}: fine for a debug endpoint,
	// wrong for a contract that requires zero values to appear and timestamps as
	// RFC3339. Leaving it nil keeps the current behaviour, so existing generated
	// code is unaffected.
	Render Renderer
	// RenderError renders a failed call. Nil means codec.RenderError, the
	// framework's errorsx envelope ({"code":<http status>,"reason":...}).
	//
	// It is a separate hook because the two shapes are separately owned: a
	// contract that documents {"code":"Domain.Specific"} — a string reason, no
	// numeric status in the body — cannot be served by the errorsx envelope, and
	// answering the wrong one is invisible to a client that only checks the HTTP
	// status.
	RenderError ErrorRenderer
	// Validate applies the request's default values and runs its validation. It
	// is called after the request is bound from path/query/body and before the
	// handler sees it, which is the only point where both hold: before binding
	// there is no message to default, and after the handler the request may
	// already have been written.
	//
	// It exists because binding and judging are different jobs with different
	// owners. The framework knows how to turn a request into a message; whether
	// the message means anything — a size a caller may ask for, a field the
	// contract requires, a name that is already taken — is the contract's
	// business, and it is the same judgement for every transport. Leaving it nil
	// keeps the current behaviour, so existing generated code is unaffected.
	Validate ValidateHook
	// contains filtered or unexported fields
}

type Renderer func(c *gin.Context, status int, v any)

type Route struct {
	// Method is the HTTP verb, e.g. http.MethodGet.
	Method string
	// Path is the gin route template, e.g. "/users/:id".
	Path string
	// GinHandler is the native gin handler for path/query/streaming cases.
	GinHandler gin.HandlerFunc
}

type RouteGroup struct {
	// contains filtered or unexported fields
}

type Server interface {
	// Start runs the server and blocks until it stops or errors. A graceful
	// stop returns nil.
	Start(ctx context.Context) error
	// Stop gracefully shuts the server down, honoring ctx timeout.
	Stop(ctx context.Context) error
}

type Service struct {
	// Name is the service name, e.g. "helloworld.Greeter".
	Name string
	// Register registers the gRPC business service (the generated
	// RegisterXxxServer, or additional streaming services). Nil disables gRPC.
	Register func(grpc.ServiceRegistrar)
	// Methods declares the proto-first HTTP routes; each Method's Handler is the
	// same strongly-typed function the gRPC service exposes.
	Methods []Method
	// RouteGroups declares native-gin HTTP routes (path/query params, no proto).
	RouteGroups []*RouteGroup
}

type ServiceEntry struct {
	Name   string
	Server Server
}

type ServiceGroup struct {
	// contains filtered or unexported fields
}

type ValidateHook func(ctx context.Context, req proto.Message) error