Advanced Kratos error handling package with type-safe operations and nil interface trap prevention.

中文说明

🎯 Type-Safe Error Handling: Simplified API to manipulate Kratos errors without naming conflicts ⚡ Safe Error Handling: Solves Go's notorious (*T)(nil) != nil trap through intelligent adaptation 🔄 Testing Integration: Complete testify/assert and testify/require helpers to test Kratos errors

go get github.com/orzkratos/errkratos

import "github.com/orzkratos/errkratos"

// Type-safe error conversion
err := someFunction()
if erk, ok := errkratos.As(err); ok {
    fmt.Printf("Kratos error: %s (code: %d)\n", erk.Reason, erk.Code)
}

// Error comparison
erk1 := errors.BadRequest("INVALID_INPUT", "missing field")
erk2 := errors.BadRequest("INVALID_INPUT", "wrong format")
if errkratos.Is(erk1, erk2) {
    // Same error type (reason and code match)
}

// Convert generic error to Kratos error
erk := errkratos.From(err)

import "github.com/orzkratos/errkratos/newerk"

// Configure reason code field name to store enum numeric value
newerk.SetReasonCodeFieldName("numeric_reason_code_enum")

// Create type-safe error with enum
erk := newerk.NewError(404, ErrorReason_USER_NOT_FOUND, "user %d not found", userID)

// Check error type
if newerk.IsError(err, ErrorReason_USER_NOT_FOUND, 404) {
    // Handle user not found error
}

import "github.com/orzkratos/errkratos/must/erkassert"

func TestSomething(t *testing.T) {
    var erk *errors.Error
    
    // Assert no error (handles nil interface with safe checks)
    erkassert.NoError(t, erk)
    
    // Assert error exists
    erk = errors.InternalServer("SERVER_ERROR", "database failed")
    erkassert.Error(t, erk)
    
    // Assert error equivalence
    expected := errors.BadRequest("INVALID_INPUT", "test")
    erkassert.Is(t, expected, erk)
}

import "github.com/orzkratos/errkratos/must/erkrequire"

func TestCritical(t *testing.T) {
    var erk *errors.Error

    // Require no error (stops test at once if error exists)
    erkrequire.NoError(t, erk)

    // Continue when no error...
}

import "github.com/orzkratos/errkratos/must/erkmust"

func criticalOperation() {
    erk := doSomethingImportant()
    
    // Panic if error exists (with structured logging)
    erkmust.Done(erk)

    // Use Must (same function, different name)
    erkmust.Must(erk)
}

errkratos/
├── errors.go           # Core API (As, Is, From)
├── newerk/             # Concise error creation API
├── erkadapt/           # Nil interface adaptation
├── must/               # Testing and enforcement tools
│   ├── erkassert/      # testify/assert helpers
│   ├── erkrequire/     # testify/require helpers
│   └── erkmust/        # Production panic utilities
└── internal/
    └── errorspb/       # Example error definitions

Go has a known issue where a typed nil value doesn't match nil when converted to interface:

var erk *errors.Error = nil
var err error = erk
fmt.Println(erk == nil)  // true
fmt.Println(err == nil)  // false (!!)

This causes issues in error handling. errkratos solves this through intelligent adaptation in each function.

The Erk type alias avoids import conflicts between standard errors package and Kratos errors:

// Instead of this confusion:
import (
    stderrors "errors"
    "github.com/go-kratos/kratos/v2/errors"
)

// Just use:
import "github.com/orzkratos/errkratos"
// And work with errkratos.Erk

• ebzkratos - Error type that doesn't implement error interface

MIT License. See LICENSE.

Contributions are welcome! Report bugs, suggest features, and contribute code:

• 🐛 Found a mistake? Open an issue on GitHub with reproduction steps
• 💡 Have a feature idea? Create an issue to discuss the suggestion
• 📖 Documentation confusing? Report it so we can improve
• 🚀 Need new features? Share the use cases to help us understand requirements
• ⚡ Performance issue? Help us optimize through reporting slow operations
• 🔧 Configuration problem? Ask questions about complex setups
• 📢 Follow project progress? Watch the repo to get new releases and features
• 🌟 Success stories? Share how this package improved the workflow
• 💬 Feedback? We welcome suggestions and comments

New code contributions, follow this process:

1. Fork: Fork the repo on GitHub (using the webpage UI).
2. Clone: Clone the forked project (git clone https://github.com/yourname/repo-name.git).
3. Navigate: Navigate to the cloned project (cd repo-name)
4. Branch: Create a feature branch (git checkout -b feature/xxx).
5. Code: Implement the changes with comprehensive tests
6. Testing: (Golang project) Ensure tests pass (go test ./...) and follow Go code style conventions
7. Documentation: Update documentation to support client-facing changes and use significant commit messages
8. Stage: Stage changes (git add .)
9. Commit: Commit changes (git commit -m "Add feature xxx") ensuring backward compatible code
10. Push: Push to the branch (git push origin feature/xxx).
11. PR: Open a merge request on GitHub (on the GitHub webpage) with detailed description.

Please ensure tests pass and include relevant documentation updates.

Welcome to contribute to this project via submitting merge requests and reporting issues.

Project Support:

• ⭐ Give GitHub stars if this project helps you
• 🤝 Share with teammates and (golang) programming friends
• 📝 Write tech blogs about development tools and workflows - we provide content writing support
• 🌟 Join the ecosystem - committed to supporting open source and the (golang) development scene

Have Fun Coding with this package! 🎉🎉🎉