feat(code): allow any code type (#94)

* feat(code): allow any code type

Change Code(...) to accept any and Code() to return any.
Update docs/tests for int and string codes.
Fix stacktrace path normalization in module mode.

BREAKING CHANGE: OopsError.Code() now returns any (was string).

* refactor(code): extract getDeepestErrorCode

---------

Co-authored-by: Andy <>

Author: AndyCokeZero

README.md

@@ -181,7 +181,7 @@ The `oops.OopsError` builder must finish with either `.Errorf(...)`, `.Wrap(...)
 | --------------------------------------- | --------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
 | `.With(string, any)`                    | `err.Context() map[string]any`          | Supply a list of attributes key+value. Values of type `func() any {}` are accepted and evaluated lazily.                                                                                   |
 | `.WithContext(context.Context, ...any)` | `err.Context() map[string]any`          | Supply a list of values declared in context. Values of type `func() any {}` are accepted and evaluated lazily.                                                                             |
-| `.Code(string)`                         | `err.Code() string`                     | Set a code or slug that describes the error. Error messages are intended to be read by humans, but such code is expected to be read by machines and be transported over different services |
+| `.Code(any)`                            | `err.Code() any`                        | Set a code or slug that describes the error. Error messages are intended to be read by humans, but such code is expected to be read by machines and be transported over different services |
 | `.Public(string)`                       | `err.Public() string`                   | Set a message that is safe to show to an end user                                                                                                                                          |
 | `.Time(time.Time)`                      | `err.Time() time.Time`                  | Set the error time (default: `time.Now()`)                                                                                                                                                 |
 | `.Since(time.Time)`                     | `err.Duration() time.Duration`          | Set the error duration                                                                                                                                                                     |

builder.go

@@ -60,7 +60,7 @@ func newBuilder() OopsErrorBuilder {
 	return OopsErrorBuilder{
 		err:      nil,
 		msg:      "",
-		code:     "",
+		code:     nil,
 		time:     time.Now(),
 		duration: 0,
 
@@ -316,7 +316,7 @@ func (o OopsErrorBuilder) Assertf(condition bool, msg string, args ...any) OopsE
 // Example:
 //
 //	oops.Code("database_connection_failed").Errorf("connection timeout")
-func (o OopsErrorBuilder) Code(code string) OopsErrorBuilder {
+func (o OopsErrorBuilder) Code(code any) OopsErrorBuilder {
 	o2 := o.copy()
 	o2.code = code
 	return o2

docs/API.md

@@ -51,7 +51,7 @@ The Oops library uses a fluent builder pattern. All methods return an `*oops.Oop
 
 ### Context Methods
 
-#### `.Code(code string) OopsErrorBuilder`
+#### `.Code(code any) OopsErrorBuilder`
 Sets an error code for machine-readable identification.
 
 ```go
@@ -251,7 +251,7 @@ The `OopsError` type implements the standard `error` interface and provides addi
 ```go
 type OopsError interface {
     error
-    Code() string
+    Code() any
     Time() time.Time
     Duration() time.Duration
     Domain() string
@@ -303,4 +303,4 @@ logger.WithField("error", err).Error("file operation failed")
 logger := slog.New(slog.NewJSONHandler(os.Stdout, nil))
 err := oops.Errorf("network timeout")
 logger.Error("network error", slog.Any("error", err))
-``` 
+``` 

docs/ARCHITECTURE.md

@@ -29,7 +29,7 @@ err := oops.
 ```go
 type OopsErrorBuilder interface {
     // Context methods
-    Code(code string) OopsErrorBuilder
+    Code(code any) OopsErrorBuilder
     In(domain string) OopsErrorBuilder
     Tags(tags ...string) OopsErrorBuilder
     Trace(trace string) OopsErrorBuilder
@@ -193,4 +193,4 @@ The Oops library is designed with a focus on:
 4. **Integration**: Works with existing logging systems
 5. **Debugging**: Rich context for faster issue resolution
 
-The architecture supports these goals through careful design of interfaces, efficient data structures, and thoughtful integration patterns. 
+The architecture supports these goals through careful design of interfaces, efficient data structures, and thoughtful integration patterns. 

docs/FAQ.md

@@ -304,12 +304,12 @@ func TestUserProcessing(t *testing.T) {
 ```go
 type MockOopsError struct {
     message string
-    code    string
+    code    any
     domain  string
 }
 
 func (m *MockOopsError) Error() string { return m.message }
-func (m *MockOopsError) Code() string  { return m.code }
+func (m *MockOopsError) Code() any    { return m.code }
 func (m *MockOopsError) Domain() string { return m.domain }
 // ... implement other methods as needed
 ```
@@ -347,7 +347,7 @@ if errors.As(err, &oopsErr) {
 var oopsErr oops.OopsError
 if errors.As(err, &oopsErr) {
     code := oopsErr.Code()
-    fmt.Printf("Error code: %s\n", code)
+    fmt.Printf("Error code: %v\n", code)
 }
 ```
 
@@ -357,7 +357,7 @@ if errors.As(err, &oopsErr) {
 var oopsErr oops.OopsError
 if errors.As(err, &oopsErr) {
     // This is an Oops error
-    fmt.Printf("Code: %s\n", oopsErr.Code())
+    fmt.Printf("Code: %v\n", oopsErr.Code())
 } else {
     // This is not an Oops error
     fmt.Printf("Standard error: %s\n", err.Error())

error.go

@@ -44,7 +44,7 @@ type OopsError struct {
 	// Core error information
 	err      error         // The underlying error being wrapped
 	msg      string        // Additional error message
-	code     string        // Machine-readable error code/slug
+	code     any           // Machine-readable error code/slug (any JSON/log-friendly type)
 	time     time.Time     // When the error occurred
 	duration time.Duration // Duration associated with the error
 
@@ -111,13 +111,23 @@ func (o OopsError) Error() string {
 // Code returns the error code from the deepest error in the chain.
 // Error codes are machine-readable identifiers that can be used for
 // programmatic error handling and cross-service error correlation.
-func (o OopsError) Code() string {
-	return getDeepestErrorAttribute(
-		o,
-		func(e OopsError) string {
-			return e.code
-		},
-	)
+func (o OopsError) Code() any {
+	return getDeepestErrorCode(o)
+}
+
+func getDeepestErrorCode(err OopsError) any {
+	if err.err == nil {
+		return err.code
+	}
+
+	if child, ok := AsOops(err.err); ok {
+		deepest := getDeepestErrorCode(child)
+		if deepest != nil {
+			return deepest
+		}
+	}
+
+	return err.code
 }
 
 // Time returns the timestamp when the error occurred.
@@ -434,8 +444,8 @@ func (o OopsError) LogValue() slog.Value { //nolint:gocyclo
 		attrs = append(attrs, slog.String("err", err))
 	}
 
-	if code := o.Code(); code != "" {
-		attrs = append(attrs, slog.String("code", code))
+	if code := o.Code(); code != nil {
+		attrs = append(attrs, slog.Any("code", code))
 	}
 
 	if t := o.Time(); t != (time.Time{}) {
@@ -546,7 +556,7 @@ func (o OopsError) ToMap() map[string]any { //nolint:gocyclo
 		payload["error"] = err
 	}
 
-	if code := o.Code(); code != "" {
+	if code := o.Code(); code != nil {
 		payload["code"] = code
 	}
 
@@ -669,8 +679,8 @@ func (o *OopsError) formatVerbose() string { //nolint:gocyclo
 	var output strings.Builder
 	_, _ = fmt.Fprintf(&output, "Oops: %s\n", o.Error())
 
-	if code := o.Code(); code != "" {
-		_, _ = fmt.Fprintf(&output, "Code: %s\n", code)
+	if code := o.Code(); code != nil {
+		_, _ = fmt.Fprintf(&output, "Code: %v\n", code)
 	}
 
 	if t := o.Time(); t != (time.Time{}) {

helpers.go

@@ -15,7 +15,7 @@ import "errors"
 //	err := someFunction()
 //	if oopsErr, ok := oops.AsOops(err); ok {
 //	  // Access oops-specific information
-//	  fmt.Printf("Error code: %s\n", oopsErr.Code())
+//	  fmt.Printf("Error code: %v\n", oopsErr.Code())
 //	  fmt.Printf("Domain: %s\n", oopsErr.Domain())
 //	  fmt.Printf("Stacktrace: %s\n", oopsErr.Stacktrace())
 //

oops.go

@@ -73,7 +73,7 @@ func Assertf(condition bool, msg string, args ...any) OopsErrorBuilder {
 // Code set a code or slug that describes the error.
 // Error messages are intended to be read by humans, but such code is expected to
 // be read by machines and even transported over different services.
-func Code(code string) OopsErrorBuilder {
+func Code(code any) OopsErrorBuilder {
 	return newBuilder().Code(code)
 }
 

oops_test.go

@@ -938,22 +938,57 @@ func TestOopsGetDeepestErrorAttributeEdgeCases(t *testing.T) {
 
 	// Test with nil error
 	result := getDeepestErrorAttribute(OopsError{err: nil}, func(o OopsError) string {
-		return o.Code()
+		return o.domain
 	})
 	is.Empty(result)
 	// Test with non-OopsError
 	result2 := getDeepestErrorAttribute(OopsError{err: assert.AnError}, func(o OopsError) string {
-		return o.Code()
+		return o.domain
 	})
 	is.Empty(result2)
 	// Test with OopsError but no context
 	err := OopsError{err: assert.AnError}
 	result3 := getDeepestErrorAttribute(err, func(o OopsError) string {
-		return o.Code()
+		return o.domain
 	})
 	is.Empty(result3)
 }
 
+func TestOopsCodeSupportsAny(t *testing.T) {
+	is := assert.New(t)
+	t.Parallel()
+
+	err := Code(404).Wrap(assert.AnError)
+	is.Error(err)
+	is.Equal(404, err.(OopsError).Code())
+	is.Equal(404, err.(OopsError).ToMap()["code"])
+
+	inner := Code(1).Wrap(assert.AnError)
+	outer := Code(2).Wrap(inner)
+	is.Equal(1, outer.(OopsError).Code())
+	is.Equal(2, outer.(OopsError).code)
+
+	inner2 := Wrap(assert.AnError)
+	outer2 := Code(2).Wrap(inner2)
+	is.Equal(2, outer2.(OopsError).Code())
+
+	errCleared := Code(nil).Wrap(assert.AnError)
+	is.Empty(errCleared.(OopsError).Code())
+	_, hasCode := errCleared.(OopsError).ToMap()["code"]
+	is.False(hasCode)
+}
+
+func TestOopsCodeNestedLayers(t *testing.T) {
+	is := assert.New(t)
+	t.Parallel()
+
+	layer1 := newBuilder().Wrap(assert.AnError)
+	layer2 := newBuilder().Code("layer2_code").Wrap(layer1)
+	layer3 := newBuilder().Code("layer3_code").Wrap(layer2)
+
+	is.Equal("layer2_code", layer3.(OopsError).Code())
+}
+
 func TestOopsMergeNestedErrorMapEdgeCases(t *testing.T) {
 	is := assert.New(t)
 	t.Parallel()