srpc

type Codec ¶

type Codec[T any] struct {
	// ContentType is the HTTP Content-Type header to use for responses.
	ContentType string
	// KeepOpen tells this library to not close streams after client calls return.
	KeepOpen bool
	// Co encodes the given value to the returned io.Reader.
	//
	// Implementers have the guarantee that the returned reader will be copied with
	// io.Copy to the response writer, or used as request body/query on the client side.
	Co func(ctx context.Context, t T) (io.Reader, error)
	// Dec decodes data from a stream.
	Dec func(ctx context.Context, r io.Reader) (T, error)
}

Codec implements functions to enCode and Decode requests and responses.

Ideally

var value T
wire, _ := myCodec.Co(ctx, value)
got := myCodec.Dec(ctx, wire)
got == value

Should be true for every possible value of T.

func NewCodecJSON[T any]() Codec[T]

func NewCodecSeq[T any]() Codec[iter.Seq2[T, error]]

type Endpoint ¶

type Endpoint[Response, Request any] struct {
	// contains filtered or unexported fields
}

Endpoint represents a single procedure.

Both the client side and the server side can be constructed from this type.

func NewEndpoint[Response, Request any](method, path string, resc Codec[Response], reqc Codec[Request]) Endpoint[Response, Request]

func NewEndpointJSON[Response, Request any](method, path string) Endpoint[Response, Request]

func NewEndpontSeq[Response, Request any](method, path string) Endpoint[iter.Seq2[Response, error], Request]

func (e *Endpoint[Response, Request]) Register(m Mux, p Procedure[Response, Request])

func (e *Endpoint[Response, Request]) Remote(conn *Transport) Procedure[Response, Request]

func (e *Endpoint[Response, Request]) RemoteWithOrigin(origin string) Procedure[Response, Request]

type EndpointR ¶

type EndpointR[Response any] Endpoint[Response, struct{}]

EndpointR is like Endpoint for functions that take no inputs.

func (e *EndpointR[Response]) Register(m Mux, h ProcedureR[Response])

func (e *EndpointR[Response]) Remote(conn *Transport) ProcedureR[Response]

func (e *EndpointR[Response]) RemoteWithOrigin(origin string) ProcedureR[Response]

type EndpointW ¶

type EndpointW[Request any] Endpoint[struct{}, Request]

EndpointW is like Endpoint but for functions that return no content.

func (e *EndpointW[Request]) Register(m Mux, h ProcedureW[Request])

func (e *EndpointW[Request]) Remote(conn *Transport) ProcedureW[Request]

func (e *EndpointW[Request]) RemoteWithOrigin(origin string) ProcedureW[Request]

type ErrorResponse ¶

type ErrorResponse interface {
	Status() int
	Message() string
}

ErrorResponse can be returned by handlers to control the error code when returning an error.

type Mux ¶

type Mux interface {
	HandleFunc(pattern string, handler func(http.ResponseWriter, *http.Request))
}

Mux is the subset of *http.ServeMux that srpc requires to work.

type Procedure ¶

type Procedure[Response, Request any] = func(ctx context.Context, req Request) (Response, error)

Procedure is a function that can be called remotely.

type ProcedureR ¶

type ProcedureR[Response any] func(ctx context.Context) (Response, error)

ProcedureR is like Procedure for functions that take no parameters.

type ProcedureW ¶

type ProcedureW[Request any] func(ctx context.Context, req Request) error

ProcedureW is like Procedure, but for functions that return no value.

type Transport ¶

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

Transport can be used to connect to a remote Endpoint.

func NewTransport(origin string, client *http.Client, cookies []*http.Cookie) (*Transport, error)

type Validable ¶

type Validable interface {
	Validate() error
}

Validable represents all requests that can be validated.

All requests that implement this and that are not valid will be automatically rejected.

IMPORTANT NOTE: the validation error is returned to the client, so it should be telling enough for a user to understand what is wrong, but it should not contain internal or secret information.

type WireError ¶

type WireError struct {
	Msg  string
	Code int
}

WireError is an error that can be sent over the wire.

It allows to set HTTP status and message.

func (w *WireError) Error() string

func (w *WireError) Message() string

func (w *WireError) Status() int