gkBoot

type BasicService ¶

type BasicService struct {
	service.UsingConfig
}

BasicService

This is the typical service with no DB attached, with an associated Configuration set by WithCustomConfig ¶

It is recommended to use config.WithCustomConfig on gkBoot.Start followed by implementing member Execute function of your struct

func (b BasicService) Execute(ctx context.Context, request interface{}) (response interface{}, err error)

type BasicServiceWithDB ¶

type BasicServiceWithDB struct {
	service.UsingConfig
	service.UsingDB
}

BasicServiceWithDB

This is the typical service with custom config and DB ¶

It is recommended to use config.WithCustomConfig and config.WithDatabase on gkBoot.Start followed by implementing member Execute function of your struct

func (b BasicServiceWithDB) Execute(ctx context.Context, request interface{}) (response interface{}, err error)

type HttpDecoder ¶

type HttpDecoder interface {
	Decode(ctx context.Context, httpRequest *http.Request) (request interface{}, err error)
}

HttpDecoder

Objects that implement this interface will pass the defined function to the decoder part of the go-kit route definition

type JSONBody ¶ added in v0.3.0

type JSONBody struct{}

JSONBody

When embedded into a request, flags the request as a JSON body to allow for automatic decoding.

type Requester ¶ added in v1.3.0

type Requester interface {
	Request(ctx context.Context) (*http.Request, error)
}

Requester is an interface that defines the Request method for making HTTP requests.

The Request method takes a context.Context object as a parameter and returns an *http.Request object and an error. The ctx parameter is used to pass any optional cancellation signals or deadlines to the Request method.

The Request method is responsible for creating and returning an *http.Request object that represents the HTTP request to be made. If there is an error while creating the request, the error should be returned.

Example Usage:

type MyRequester struct {}

func (r *MyRequester) Request(ctx context.Context) (*http.Request, error) {
    // Implement the logic to create and return the *http.Request object
}

func main() {
    requester := &MyRequester{}
    request, err := requester.Request(context.Background())
    if err != nil {
        // Handle error
    }
    // Use the *http.Request object for making the HTTP request
}

type ServiceRequest ¶

type ServiceRequest struct {
	Request request.HttpRequest
	Service service.Service
}

ServiceRequest

The request and service provided in this structure are submitted to the Start functions. The requests, when called from the http client, will route to the associated service to execute the business logic of the Execute method.

type SkipClientValidation ¶ added in v1.0.0

type SkipClientValidation interface {
	SkipClientValidation()
}

SkipClientValidation is an interface that can be implemented by a request object to skip client validation during the generation of an *http.Request object. If a request object implements this interface, the validation step will be bypassed and the request object will not be validated before generating the HTTP request.

Example Usage:

type MyRequest struct {
    // request fields
}

func (r *MyRequest) Info() request.HttpRouteInfo {
    // return HttpRouteInfo
}

func (r *MyRequest) Validate() error {
    // return validation error
}

func (r *MyRequest) SkipClientValidation() {
    // implement the interface to skip client validation
}

func main() {
    request := &MyRequest{}

    // Generate *http.Request object
    httpRequest, err := GenerateClientRequest(baseUrl, request)
    if err != nil {
        // Handle error
    }
    // Use the *http.Request object for making the HTTP request
}

type UsingSkipClientValidation ¶ added in v1.2.7

type UsingSkipClientValidation struct{}

UsingSkipClientValidation is a type that can be used to indicate that client validation should be skipped during the generation of an *http.Request object. If a request object contains a field of type UsingSkipClientValidation and is used as an argument for generating an *http.Request object, the validation step will be bypassed and the request object will not be validated before generating the HTTP request.

func (u UsingSkipClientValidation) SkipClientValidation()