73b8873aae
Makes pkg/errors a thin compatibility layer that re-exports from pkg/log. All error handling functions now have canonical implementations in pkg/log. Migration guide in package documentation: - errors.Error -> log.Err - errors.E -> log.E - errors.Code -> log.NewCode - errors.New -> log.NewError Fixes behavior consistency: - E(op, msg, nil) now creates an error (for errors without cause) - Wrap(nil, op, msg) returns nil (for conditional wrapping) - WrapCode returns nil only when both err is nil AND code is empty Closes #128 Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
128 lines
3.2 KiB
Go
128 lines
3.2 KiB
Go
// Package errors provides structured error handling for Core applications.
|
|
//
|
|
// Deprecated: Use pkg/log instead. This package is maintained for backward
|
|
// compatibility and will be removed in a future version. All error handling
|
|
// functions are now available in pkg/log:
|
|
//
|
|
// // Instead of:
|
|
// import "github.com/host-uk/core/pkg/errors"
|
|
// err := errors.E("op", "msg", cause)
|
|
//
|
|
// // Use:
|
|
// import "github.com/host-uk/core/pkg/log"
|
|
// err := log.E("op", "msg", cause)
|
|
//
|
|
// Migration guide:
|
|
// - errors.Error -> log.Err
|
|
// - errors.E -> log.E
|
|
// - errors.Wrap -> log.Wrap
|
|
// - errors.WrapCode -> log.WrapCode
|
|
// - errors.Code -> log.NewCode
|
|
// - errors.New -> log.NewError
|
|
// - errors.Is -> log.Is
|
|
// - errors.As -> log.As
|
|
// - errors.Join -> log.Join
|
|
// - errors.Op -> log.Op
|
|
// - errors.ErrCode -> log.ErrCode
|
|
// - errors.Message -> log.Message
|
|
// - errors.Root -> log.Root
|
|
package errors
|
|
|
|
import (
|
|
"github.com/host-uk/core/pkg/log"
|
|
)
|
|
|
|
// Error represents a structured error with operational context.
|
|
//
|
|
// Deprecated: Use log.Err instead.
|
|
type Error = log.Err
|
|
|
|
// E creates a new Error with operation context.
|
|
//
|
|
// Deprecated: Use log.E instead.
|
|
func E(op, msg string, err error) error {
|
|
return log.E(op, msg, err)
|
|
}
|
|
|
|
// Wrap wraps an error with operation context.
|
|
// Returns nil if err is nil.
|
|
//
|
|
// Deprecated: Use log.Wrap instead.
|
|
func Wrap(err error, op, msg string) error {
|
|
return log.Wrap(err, op, msg)
|
|
}
|
|
|
|
// WrapCode wraps an error with operation context and an error code.
|
|
//
|
|
// Deprecated: Use log.WrapCode instead.
|
|
func WrapCode(err error, code, op, msg string) error {
|
|
return log.WrapCode(err, code, op, msg)
|
|
}
|
|
|
|
// Code creates an error with just a code and message.
|
|
//
|
|
// Deprecated: Use log.NewCode instead.
|
|
func Code(code, msg string) error {
|
|
return log.NewCode(code, msg)
|
|
}
|
|
|
|
// --- Standard library wrappers ---
|
|
|
|
// Is reports whether any error in err's tree matches target.
|
|
//
|
|
// Deprecated: Use log.Is instead.
|
|
func Is(err, target error) bool {
|
|
return log.Is(err, target)
|
|
}
|
|
|
|
// As finds the first error in err's tree that matches target.
|
|
//
|
|
// Deprecated: Use log.As instead.
|
|
func As(err error, target any) bool {
|
|
return log.As(err, target)
|
|
}
|
|
|
|
// New returns an error with the given text.
|
|
//
|
|
// Deprecated: Use log.NewError instead.
|
|
func New(text string) error {
|
|
return log.NewError(text)
|
|
}
|
|
|
|
// Join returns an error that wraps the given errors.
|
|
//
|
|
// Deprecated: Use log.Join instead.
|
|
func Join(errs ...error) error {
|
|
return log.Join(errs...)
|
|
}
|
|
|
|
// --- Helper functions ---
|
|
|
|
// Op extracts the operation from an error, or empty string if not an Error.
|
|
//
|
|
// Deprecated: Use log.Op instead.
|
|
func Op(err error) string {
|
|
return log.Op(err)
|
|
}
|
|
|
|
// ErrCode extracts the error code, or empty string if not set.
|
|
//
|
|
// Deprecated: Use log.ErrCode instead.
|
|
func ErrCode(err error) string {
|
|
return log.ErrCode(err)
|
|
}
|
|
|
|
// Message extracts the message from an error.
|
|
// For Error types, returns Msg; otherwise returns err.Error().
|
|
//
|
|
// Deprecated: Use log.Message instead.
|
|
func Message(err error) string {
|
|
return log.Message(err)
|
|
}
|
|
|
|
// Root returns the deepest error in the chain.
|
|
//
|
|
// Deprecated: Use log.Root instead.
|
|
func Root(err error) error {
|
|
return log.Root(err)
|
|
}
|