Giter Club home page Giter Club logo

Comments (2)

ardan-bkennedy avatar ardan-bkennedy commented on August 10, 2024

Start with this code that is inside the middleware for error handling.

switch {
    case response.IsError(err):
    reqErr := response.GetError(err)

    if validate.IsFieldErrors(reqErr.Err) {
        fieldErrors := validate.GetFieldErrors(reqErr.Err)
        er = response.ErrorDocument{
            Error:  "data validation error",
            Fields: fieldErrors.Fields(),
        }
        status = reqErr.Status
        break
    }

You can see a validate.FieldError is expected to be inside an response.Error. That happens in the app layer.

    var app AppNewProduct
    if err := web.Decode(r, &app); err != nil {
        return response.NewError(err, http.StatusBadRequest)
    }

The web.Decode function is calling validate as you will see in a second. That return is wrapping the validate.FieldError inside of a response.Error. We want this so we can control the Status to be used on the response.

    if v, ok := val.(validator); ok {
        if err := v.Validate(); err != nil {
            return fmt.Errorf("unable to validate payload: %w", err)
        }
    }

Here is code inside the web.Decode call. That is an interface call, so we need to find a concrete implementation.

    func (app AppNewProduct) Validate() error {
        if err := validate.Check(app); err != nil {
             return err
        }

        return nil
    }

That is calling validate.Check. Let's look at that.

    func Check(val any) error {
	if err := validate.Struct(val); err != nil {

		// Use a type assertion to get the real error value.
		verrors, ok := err.(validator.ValidationErrors)
		if !ok {
			return err
		}

		var fields FieldErrors
		for _, verror := range verrors {
			field := FieldError{
				Field: verror.Field(),
				Err:   verror.Translate(translator),
			}
			fields = append(fields, field)
		}

		return fields
	}

	return nil
}

There you have it. This function returns a FieldError, which is then passed up to the app layer through the Validate function. Once the app layer gets it, it is passed to the middleware like this.

    return response.NewError(err, http.StatusBadRequest)

So the error is embedded in the wrapping. This is done so the app layer can control the status code.

NOW, if you don't want to hide the error in a response.Error, you can add a case to the middleare for this specific error type.

from service.

khatibomar avatar khatibomar commented on August 10, 2024

Thank you, now it's clear for me.

from service.

Related Issues (20)

Recommend Projects

  • React photo React

    A declarative, efficient, and flexible JavaScript library for building user interfaces.

  • Vue.js photo Vue.js

    🖖 Vue.js is a progressive, incrementally-adoptable JavaScript framework for building UI on the web.

  • Typescript photo Typescript

    TypeScript is a superset of JavaScript that compiles to clean JavaScript output.

  • TensorFlow photo TensorFlow

    An Open Source Machine Learning Framework for Everyone

  • Django photo Django

    The Web framework for perfectionists with deadlines.

  • D3 photo D3

    Bring data to life with SVG, Canvas and HTML. 📊📈🎉

Recommend Topics

  • javascript

    JavaScript (JS) is a lightweight interpreted programming language with first-class functions.

  • web

    Some thing interesting about web. New door for the world.

  • server

    A server is a program made to process requests and deliver data to clients.

  • Machine learning

    Machine learning is a way of modeling and interpreting data that allows a piece of software to respond intelligently.

  • Game

    Some thing interesting about game, make everyone happy.

Recommend Org

  • Facebook photo Facebook

    We are working to build community through open source technology. NB: members must have two-factor auth.

  • Microsoft photo Microsoft

    Open source projects and samples from Microsoft.

  • Google photo Google

    Google ❤️ Open Source for everyone.

  • D3 photo D3

    Data-Driven Documents codes.