errs

README

Errors

Golang package to create constant sentinel errors.

Install

go get github.com/nicolasparada/go-errs

Usage

You can create your own constant sentinel errors as if they were a string.

package myapp

import (
    errs "github.com/nicolasparada/go-errs"
)

const (
    ErrInvalidEmail = errs.InvalidArgumentError("myapp: invalid email")
)

You can use errors.Is to check for the error group, which are exposed in the package.

Or you can use errors.As to check if your error is of type errs.Error so you can extract the error kind as well.

package main

import (
    "errors"
    "fmt"

    "myapp"
    errs "github.com/nicolasparada/go-errs"
)

func main() {
    ok := errors.Is(myapp.ErrInvalidEmail, errs.InvalidArgument)
    fmt.Println(ok)
    // Output: true

    var e errs.Error
    ok = errors.As(myapp.ErrInvalidEmail, &e)
    fmt.Println(ok)
    // Output: true

    ok = e.Kind() == errs.KindInvalidArgument
    fmt.Println(ok)
    // Output: true
}

HTTP Errors

You can use the httperrs subpackage to quickly convert an error defined using this package into an HTTP status code.

package main

import (
    "errors"
    "fmt"

    "myapp"
    "github.com/nicolasparada/go-errs/httperrs"
)

func main() {
    got := httperrs.Code(myapp.ErrInvalidEmail)
    fmt.Println(got)
    // Output: 422
}

Documentation

Overview

Package errs exposes a common set of error types. It is designed so these errors can be declared as constants.

Index

• Constants
• type ConflictError
  • func (e ConflictError) Error() string
  • func (e ConflictError) Is(target error) bool
  • func (e ConflictError) Kind() Kind
• type Error
• type GoneError
  • func (e GoneError) Error() string
  • func (e GoneError) Is(target error) bool
  • func (e GoneError) Kind() Kind
• type InvalidArgumentError
  • func (e InvalidArgumentError) Error() string
  • func (e InvalidArgumentError) Is(target error) bool
  • func (e InvalidArgumentError) Kind() Kind
• type Kind
• type NotFoundError
  • func (e NotFoundError) Error() string
  • func (e NotFoundError) Is(target error) bool
  • func (e NotFoundError) Kind() Kind
• type PermissionDeniedError
  • func (e PermissionDeniedError) Error() string
  • func (e PermissionDeniedError) Is(target error) bool
  • func (e PermissionDeniedError) Kind() Kind
• type UnauthenticatedError
  • func (e UnauthenticatedError) Error() string
  • func (e UnauthenticatedError) Is(target error) bool
  • func (e UnauthenticatedError) Kind() Kind

Examples

• Error

Constants

const (
	Unauthenticated  = UnauthenticatedError("unauthenticated")
	InvalidArgument  = InvalidArgumentError("invalid argument")
	NotFound         = NotFoundError("not found")
	Conflict         = ConflictError("conflict")
	PermissionDenied = PermissionDeniedError("permission denied")
	Gone             = GoneError("gone")
)

Types

type ConflictError

type ConflictError string

func (ConflictError) Error

func (e ConflictError) Error() string

func (ConflictError) Is

func (e ConflictError) Is(target error) bool

func (ConflictError) Kind

func (e ConflictError) Kind() Kind

type Error

type Error interface {
	error
	Kind() Kind
}

Error interface represents an error that was built using this very package. Meaning it exposes a Kind() method.

Example

const err = UnauthenticatedError("an unauthenticated error")
fmt.Println(err.Kind() == KindUnauthenticated)

Output:

true

type GoneError

type GoneError string

func (GoneError) Error

func (e GoneError) Error() string

func (GoneError) Is

func (e GoneError) Is(target error) bool

func (GoneError) Kind

func (e GoneError) Kind() Kind

type InvalidArgumentError

type InvalidArgumentError string

func (InvalidArgumentError) Error

func (e InvalidArgumentError) Error() string

func (InvalidArgumentError) Is

func (e InvalidArgumentError) Is(target error) bool

func (InvalidArgumentError) Kind

func (e InvalidArgumentError) Kind() Kind

type Kind

type Kind string

Kind enum.

const (
	KindUnauthenticated  Kind = "unauthenticated"
	KindInvalidArgument  Kind = "invalid_argument"
	KindNotFound         Kind = "not_found"
	KindConflict         Kind = "conflict"
	KindPermissionDenied Kind = "permission_denied"
	KindGone             Kind = "gone"
)

type NotFoundError

type NotFoundError string

func (NotFoundError) Error

func (e NotFoundError) Error() string

func (NotFoundError) Is

func (e NotFoundError) Is(target error) bool

func (NotFoundError) Kind

func (e NotFoundError) Kind() Kind

type PermissionDeniedError

type PermissionDeniedError string

func (PermissionDeniedError) Error

func (e PermissionDeniedError) Error() string

func (PermissionDeniedError) Is

func (e PermissionDeniedError) Is(target error) bool

func (PermissionDeniedError) Kind

func (e PermissionDeniedError) Kind() Kind

type UnauthenticatedError

type UnauthenticatedError string

func (UnauthenticatedError) Error

func (e UnauthenticatedError) Error() string

func (UnauthenticatedError) Is

func (e UnauthenticatedError) Is(target error) bool

func (UnauthenticatedError) Kind

func (e UnauthenticatedError) Kind() Kind