Creating a custom error in golang for http responses

i wanted to create custom errors for my authentication service that i am currently working on.
Since i have to create a error for every http responses, and i am fairly new to golang i am facing difficulties.
The below code is the replica of the javascript code code that i wanted to implement here in go.

export abstract class CustomError extends Error {
abstract statusCode: number;

constructor(message: string) {
    super(message);

    Object.setPrototypeOf(this, CustomError.prototype);
}

abstract serializeErrors(): { message: string; field?: string }[];
}

To create extended classes based on the custom error like this

import { CustomError } from "./custom-error";

export class NotFoundError extends CustomError {
statusCode = 404;

constructor() {
    super("Route not found");

    Object.setPrototypeOf(this, NotFoundError.prototype);
}

serializeErrors() {
    return [{ message: "Not Found" }];
 }
}

so that i can be thrown or logged from the main file i.e.
const existingUser = await User.findOne({ email });

    if (existingUser) {
        throw new BadRequestError("Email is already in use");
    }

so in simple language i wanted to create an object/model of CustomErrors that can help to create more diverse Erros like BadRequestError()

so, i need help regarding creating this one. And this is my first question here

In Go you create a custom error type simply by implementing the error interface.

The error interface is:

type error interface {
    Error() string
}

[if you're completely new to Go, I suggest starting with the Tour of Go on interfaces]

For example:

type SyntaxError struct {
    msg    string // description of error
    Offset int64  // error occurred after reading Offset bytes
}

func (e *SyntaxError) Error() string { return e.msg }

See this official Go blog post for more details.

This is for error types; if you're specifically looking for HTTP errors, those in a server are done by writing an error status to a http.ResponseWriter along with the error message you need, and you can use the helper http.Error for this. Example:

func myHandler(w http.ResponseWriter, req *http.Request) {
  if (somethingIsWrong) {
    http.Error(w, "the error message", http.StatusBadRequest)
  }
}

The last param to http.Error is the HTTP status; check out the net/http stdlib package docs for the options you have there.

Now, to connect the two, http.Error would typically use the Error() method of your custom error as the message, and the status is really application specific.

If you want http error responses in plain text, http.Error should be your choice. But if your authentication service needs error response in specific format (JSON/XML) then you need to create custom http errors which can be serialized and written into the response.

To create custom http error responses for JSON format (for XML format modify serialization), first you need to create some types -

type ErrFields map[string]string  // Error field-value pair type

type ResponseError struct {
	Msg    string `json:"message"` // Error message
	Status int    `json:"status"`  // Http status code
	Data   ErrFields 			   // For extra error fields e.g. reason, details, etc.
}

type ErrList []ResponseError       // Multiple http errors type

Methods for ResponseError type -

// AddErrField adds a new field to the response error with given key and value
func (err *ResponseError) AddErrField(key, value string) {
	if err.Data == nil {
		err.Data = make(ErrFields)
	}
	err.Data[key] = value
}

// RemoveErrField removes existing field matching given key from response error
func (err *ResponseError) RemoveErrField(key string) {
	delete(err.Data, key)
}

// MarshalJSON marshals the response error into json 
func (err *ResponseError) MarshalJSON() ([]byte, error) {
	// Determine json field name for error message
	errType := reflect.TypeOf(*err)
	msgField, ok := errType.FieldByName("Msg")
	msgJsonName := "message"
	if ok {
		msgJsonTag := msgField.Tag.Get("json")
		if msgJsonTag != "" {
			msgJsonName = msgJsonTag
		}
	}
	// Determine json field name for error status code
	statusField, ok := errType.FieldByName("Status")
	statusJsonName := "status"
	if ok {
		statusJsonTag := statusField.Tag.Get("json")
		if statusJsonTag != "" {
			statusJsonName = statusJsonTag
		}
	}
	fieldMap := make(map[string]string)
	fieldMap[msgJsonName] = err.Msg
	fieldMap[statusJsonName] = fmt.Sprintf("%d", err.Status)
	for key, value := range err.Data {
		fieldMap[key] = value
	}
	return json.Marshal(fieldMap)
}

// SerializeJSON converts response error into serialized json string
func (resErr *ResponseError) SerializeJSON() (string, error) {
	value, err := json.Marshal(resErr)
	if err != nil {
		return "", err
	}
	return string(value), nil
}

Methods for ErrList type -

// SerializeJSON converts error list into serialized json string
func (errList ErrList) SerializeJSON() (string, error) {
	value, err := json.Marshal(errList)
	if err != nil {
		return "", err
	}
	return string(value), nil
}

Now you can create custom http error responses by creating different values of ResponseError type -

// Error returns a general response error
func Error(msg string, status int) ResponseError {
	return ResponseError{msg, status, nil}
}

// Errors returns a error list containing given response errors
func Errors(errors ...ResponseError) ErrList {
	return errors
}

// Specific HTTP error responses

func ErrorNotFound() ResponseError {
	return Error("not found", http.StatusNotFound)
}

func ErrorBadRequest() ResponseError {
	return Error("bad request", http.StatusBadRequest)
}

func ErrorInternalServerError() ResponseError {
	return Error("internal server error", http.StatusInternalServerError)
}

func ErrorForbidden() ResponseError {
	return Error("forbidden", http.StatusForbidden)
}

You can add/remove custom fields to the ResponseError values -

notFoundErr := ErrorNotFound()
notFoundErr.AddErrField("reason", "given 'id' does not exist")
notFoundErr.RemoveErrField("reason")

Since in Go there is no concept of throw, you can only return response error from a function -

func Foo() (resErr ResponseError, ok bool) {
    ...
    if existingUser {
       resErr = ErrorBadRequest()
       resErr.AddErrField("reason", "Email is already in use")
       return resErr, true
    }
    ...
    return ResponseError{}, false
}

To serialize response error into JSON -

resErr, ok := Foo()
if !ok {
    json, err := resErr.SerializeJSON()
    if err != nil {
        // Handle serialization error
    }
}

See the Go playground example here.