Documentation
¶
Index ¶
- func Finish(returnErr *error, blk func() error)
- func HasTag(err error, tags ...any) bool
- func LookupContext(err error) (context.Context, bool)
- func LookupDetail(err error) (string, bool)
- func Merge(errs ...error) error
- func Tag[Tag ~struct{}](err error, tag Tag) error
- type Error
- type ErrorHandler
- type UserError
- type WithBuilder
- func (w WithBuilder) Context(ctx context.Context) WithBuilder
- func (w WithBuilder) Detail(detail string) WithBuilder
- func (w WithBuilder) Detailf(format string, a ...any) WithBuilder
- func (w WithBuilder) Error() string
- func (w WithBuilder) Unwrap() error
- func (w WithBuilder) Wrap(err error) WithBuilder
Examples ¶
Constants ¶
This section is empty.
Variables ¶
This section is empty.
Functions ¶
func Finish ¶
Finish is a helper function that can be used from a deferred context.
Usage:
defer errorkit.Finish(&returnError, rows.Close)
Example (SqlRows) ¶
package main
import (
"database/sql"
"go.llib.dev/frameless/pkg/errorkit"
)
func main() {
var db *sql.DB
myExampleFunction := func() (rErr error) {
rows, err := db.Query("SELECT FROM mytable")
if err != nil {
return err
}
defer errorkit.Finish(&rErr, rows.Close)
for rows.Next() {
if err := rows.Scan(); err != nil {
return err
}
}
return rows.Err()
}
if err := myExampleFunction(); err != nil {
panic(err.Error())
}
}
func HasTag ¶
Example ¶
package main
import (
"fmt"
"go.llib.dev/frameless/pkg/errorkit"
)
func main() {
type MyTag struct{}
err := fmt.Errorf("foo bar baz")
errorkit.HasTag(err, MyTag{}) // false
err = errorkit.Tag(err, MyTag{})
errorkit.HasTag(err, MyTag{}) // true
}
func LookupDetail ¶
func Merge ¶
Merge will combine all given non nil error values into a single error value. If no valid error is given, nil is returned. If only a single non nil error value is given, the error value is returned.
Example ¶
package main
import (
"fmt"
"go.llib.dev/frameless/pkg/errorkit"
)
func main() {
// creates an error value that combines the input errors.
err := errorkit.Merge(fmt.Errorf("foo"), fmt.Errorf("bar"), nil)
_ = err
}
Types ¶
type Error ¶
type Error string
Error is an implementation for the error interface that allow you to declare exported globals with the `consttypes` keyword.
TL;DR: consttypes ErrSomething errorkit.Error = "something is an error"
type ErrorHandler ¶
type ErrorHandler interface {
// HandleError allow the interactor implementation to be notified about unexpected situations.
HandleError(ctx context.Context, err error) error
}
ErrorHandler describes that an object able to handle error use-cases for its purpose.
For e.g. if the component is a pubsub subscription event handler, then implementing ErrorHandler means it suppose to handle unexpected use-cases such as connection interruption.
type UserError ¶
type UserError struct {
// ID is a constant string value that expresses the user's error scenario.
// The caller who receives the error will use this code to present the UserError to their users and,
// most likely, provide a localised error message about the error scenario to the end user.
// Traditionally this should be a string without any white space.
//
// Example: "foo-is-forbidden-with-active-baz"
ID consttypes.String
// Message is the error message meant to be read by a developer working on the implementation of the caller.
// It is not expected to be seen by end users.
// It might be written in English for portability reasons.
//
// Example: "Authentication failed due to incorrect username or password."
Message consttypes.String
}
Example ¶
package main
import (
"errors"
"fmt"
"math/rand"
"go.llib.dev/frameless/pkg/errorkit"
)
func main() {
fooEntityID := rand.Int()
bazEntityID := rand.Int()
usrerr := errorkit.UserError{
ID: "foo-is-forbidden-with-active-baz",
Message: "It is forbidden to execute Foo when you have an active Baz",
}
var err error = usrerr.With().Detailf("Foo(ID:%d) /Baz(ID:%d)", fooEntityID, bazEntityID)
// add some details using error wrapping
err = fmt.Errorf("some wrapper layer: %w", err)
// retrieve with errors pkg
if ue := (errorkit.UserError{}); errors.As(err, &ue) {
fmt.Printf("%#v\n", ue)
}
if errors.Is(err, errorkit.UserError{}) {
fmt.Println("it's a Layer 8 error")
}
// retrieve with errorkit pkg
if userError, ok := errorkit.LookupUserError(err); ok {
fmt.Printf("%#v\n", userError)
}
}
func LookupUserError ¶
Example ¶
package main
import (
"fmt"
"go.llib.dev/frameless/pkg/errorkit"
)
func main() {
err := errorkit.UserError{
ID: "constant-err-scenario-code",
Message: "some message for the dev",
}
if userError, ok := errorkit.LookupUserError(err); ok {
fmt.Printf("%#v\n", userError)
}
}
func (UserError) With ¶
func (err UserError) With() WithBuilder
Example ¶
package main
import (
"go.llib.dev/frameless/pkg/errorkit"
)
func main() {
usrErr := errorkit.UserError{
ID: "foo-is-forbidden-with-active-baz",
Message: "It is forbidden to execute Foo when you have an active Baz",
}
// returns with Err that has additional concrete details
_ = usrErr.With().Detailf("Foo(ID:%d) /Baz(ID:%d)", 42, 7)
}
type WithBuilder ¶
type WithBuilder struct{ Err error }
func With ¶
func With(err error) WithBuilder
func (WithBuilder) Context ¶
func (w WithBuilder) Context(ctx context.Context) WithBuilder
Context will combine an error with a context, so the current context can be used at the place of error handling. This can be useful if tracing ID and other helpful values are kept in the context.
Example ¶
package main
import (
"context"
"fmt"
"go.llib.dev/frameless/pkg/errorkit"
)
func main() {
err := fmt.Errorf("foo bar baz")
ctx := context.Background()
err = errorkit.With(err).
Context(ctx)
_, _ = errorkit.LookupContext(err) // ctx, true
}
func (WithBuilder) Detail ¶
func (w WithBuilder) Detail(detail string) WithBuilder
Detail will return an error that has explanation as detail attached to it.
Example ¶
package main
import (
"fmt"
"go.llib.dev/frameless/pkg/errorkit"
)
func main() {
err := fmt.Errorf("foo bar baz")
err = errorkit.With(err).
Detail("it was the foo or bar or baz")
_, _ = errorkit.LookupDetail(err) // "it was the foo or bar or baz", true
}
func (WithBuilder) Detailf ¶
func (w WithBuilder) Detailf(format string, a ...any) WithBuilder
Detailf will return an error that has explanation as detail attached to it. Detailf formats according to a fmt format specifier and returns the resulting string.
Example ¶
package main
import (
"fmt"
"go.llib.dev/frameless/pkg/errorkit"
)
func main() {
err := fmt.Errorf("foo bar baz")
err = errorkit.With(err).
Detailf("--> %s <--", "it was the foo or bar or baz")
_, _ = errorkit.LookupDetail(err) // "--> it was the foo or bar or baz <--", true
}
func (WithBuilder) Error ¶
func (w WithBuilder) Error() string
func (WithBuilder) Unwrap ¶
func (w WithBuilder) Unwrap() error
func (WithBuilder) Wrap ¶
func (w WithBuilder) Wrap(err error) WithBuilder
Source Files
Click to show internal directories.
Click to hide internal directories.