harpy

type BatchRequestMarshaler struct {
	// Target is the target writer to which the JSON-RPC batch is marshaled.
	Target io.Writer
	// contains filtered or unexported fields
}

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

type ErrorCode int

type ErrorInfo struct {
	Code    ErrorCode       `json:"code"`
	Message string          `json:"message"`
	Data    json.RawMessage `json:"data,omitempty"`
}

type ErrorOption func(*Error)

type ErrorResponse struct {
	// Version is the JSON-RPC version.
	//
	// As per the JSON-RPC specification it MUST be exactly "2.0".
	Version string `json:"jsonrpc"`

	// RequestID is the ID of the request that produced this response.
	RequestID json.RawMessage `json:"id"`

	// Error describes the error produced in response to the request.
	Error ErrorInfo `json:"error"`

	// ServerError provides more context to internal errors. The value is never
	// sent to the client.
	ServerError error `json:"-"`
}

type ExchangeLogger interface {
	// LogError logs about an error that is a result of some problem with the
	// request set as a whole.
	LogError(ctx context.Context, res ErrorResponse)

	// LogWriterError logs about an error that occured when attempting to use a
	// ResponseWriter.
	LogWriterError(ctx context.Context, err error)

	// LogNotification logs about a notification request.
	LogNotification(ctx context.Context, req Request, err error)

	// LogCall logs about a call request/response pair.
	LogCall(ctx context.Context, req Request, res Response)
}

type Exchanger interface {
	// Call handles call request and returns its response.
	Call(context.Context, Request) Response

	// Notify handles a notification request, which does not expect a response.
	//
	// It may return an error to be logged, but it is not sent to the caller.
	Notify(context.Context, Request) error
}

type Request struct {
	// Version is the JSON-RPC version.
	//
	// As per the JSON-RPC specification it MUST be exactly "2.0".
	Version string `json:"jsonrpc"`

	// ID uniquely identifies requests that expect a response, that is RPC calls
	// as opposed to notifications.
	//
	// As per the JSON-RPC specification, it MUST be a JSON string, number, or
	// null value. It SHOULD NOT normally not be null. Numbers SHOULD NOT
	// contain fractional parts.
	//
	// If the ID field itself is nil, the request is a notification.
	ID json.RawMessage `json:"id,omitempty"`

	// Method is the name of the RPC method to be invoked.
	//
	// As per the JSON-RPC specification, method names that begin with "rpc."
	// are reserved for system extensions, and MUST NOT be used for anything
	// else. Each system extension is defined in a separate specification. All
	// system extensions are OPTIONAL.
	//
	// Any requests for extension methods that are not handled internally by
	// this package are treated just like any other request, thus allowing
	// extension methods to be implemented by user-defined handlers.
	//
	// This package does not currently handle any extension methods internally.
	//
	// In accordance with the JSON-RPC specification there are no requirements
	// placed on the format of the method name. This allows server
	// implementations that provide methods with an empty name, non-ASCII names,
	// or any other value that can be represented as a JSON string.
	Method string `json:"method"`

	// Parameters holds the parameter values to be used during the invocation of
	// the method.
	//
	// As per the JSON-RPC specification it MUST be a structured value, that is
	// either a JSON array or object.
	//
	// Validation of the parameters is the responsibility of the user-defined
	// handlers.
	Parameters json.RawMessage `json:"params,omitempty"`
}

type RequestSet struct {
	// Requests contains the requests parsed from the message.
	Requests []Request

	// IsBatch is true if the requests are part of a batch.
	//
	// This is used to disambiguate between a single request and a batch that
	// contains only one request.
	IsBatch bool
}

type RequestSetReader interface {
	// Read reads the next RequestSet that is to be processed.
	//
	// It returns ctx.Err() if ctx is canceled while waiting to read the next
	// request set. If request set data is read but cannot be parsed a native
	// JSON-RPC Error is returned. Any other error indicates an IO error.
	Read(ctx context.Context) (RequestSet, error)
}

type Response interface {
	// Validate checks that the response conforms to the JSON-RPC specification.
	//
	// It returns nil if the response is valid.
	Validate() error

	// UnmarshalRequestID unmarshals the request ID in the response into v.
	UnmarshalRequestID(v any) error
	// contains filtered or unexported methods
}

type ResponseSet struct {
	// Responses contains the responses parsed from the message.
	Responses []Response

	// IsBatch is true if the responses are part of a batch.
	//
	// This is used to disambiguate between a single response and a batch that
	// contains only one response.
	IsBatch bool
}

type ResponseWriter interface {
	// WriteError writes an error response that is a result of some problem with
	// the request set as a whole.
	WriteError(ErrorResponse) error

	// WriteUnbatched writes a response to an individual request that was not
	// part of a batch.
	WriteUnbatched(Response) error

	// WriteBatched writes a response to an individual request that was part of
	// a batch.
	WriteBatched(Response) error

	// Close is called to signal that there are no more responses to be sent.
	Close() error
}

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

type RouterOption func(*Router)

type SuccessResponse struct {
	// Version is the JSON-RPC version.
	//
	// As per the JSON-RPC specification it MUST be exactly "2.0".
	Version string `json:"jsonrpc"`

	// RequestID is the ID of the request that produced this response.
	RequestID json.RawMessage `json:"id"`

	// Result is the user-defined result value produce in response to the
	// request.
	Result json.RawMessage `json:"result"`
}

type UnmarshalOption = jsonx.UnmarshalOption

type UntypedHandler func(ctx context.Context, req Request) (res any, err error)

type Validatable interface {
	// Validate returns a non-nil error if the value is invalid.
	//
	// The returned error, if non-nil, is always wrapped in a JSON-RPC "invalid
	// parameters" error, and therefore should not itself be a JSON-RPC error.
	Validate() error
}