added updated code for core wiring

1. Removed tracing
2. Skipped Registration

pkg/model/error.go

@@ -0,0 +1,128 @@
+package model
+
+import (
+	"fmt"
+	"net/http"
+	"strings"
+)
+
+// Error represents an error response.
+type Error struct {
+	Code    string `json:"code"`
+	Paths   string `json:"paths,omitempty"`
+	Message string `json:"message"`
+}
+
+// Error implements the error interface for the Error struct.
+func (e *Error) Error() string {
+	return fmt.Sprintf("Error: Code=%s, Path=%s, Message=%s", e.Code, e.Paths, e.Message)
+}
+
+// SchemaValidationErr represents a collection of schema validation failures.
+type SchemaValidationErr struct {
+	Errors []Error
+}
+
+// Error implements the error interface for SchemaValidationErr.
+func (e *SchemaValidationErr) Error() string {
+	var errorMessages []string
+	for _, err := range e.Errors {
+		errorMessages = append(errorMessages, fmt.Sprintf("%s: %s", err.Paths, err.Message))
+	}
+	return strings.Join(errorMessages, "; ")
+}
+
+// BecknError converts SchemaValidationErr into a Beckn-compliant Error response.
+func (e *SchemaValidationErr) BecknError() *Error {
+	if len(e.Errors) == 0 {
+		return &Error{
+			Code:    http.StatusText(http.StatusBadRequest),
+			Message: "Schema validation error.",
+		}
+	}
+
+	// Collect all error paths and messages
+	var paths []string
+	var messages []string
+	for _, err := range e.Errors {
+		if err.Paths != "" {
+			paths = append(paths, err.Paths)
+		}
+		messages = append(messages, err.Message)
+	}
+
+	return &Error{
+		Code:    http.StatusText(http.StatusBadRequest),
+		Paths:   strings.Join(paths, ";"),
+		Message: strings.Join(messages, "; "),
+	}
+}
+
+// SignValidationErr represents an error that occurs during signature validation.
+type SignValidationErr struct {
+	error
+}
+
+// NewSignValidationErrf creates a new SignValidationErr with a formatted message.
+func NewSignValidationErrf(format string, a ...any) *SignValidationErr {
+	return &SignValidationErr{fmt.Errorf(format, a...)}
+}
+
+// NewSignValidationErr creates a new SignValidationErr from an existing error.
+func NewSignValidationErr(e error) *SignValidationErr {
+	return &SignValidationErr{e}
+}
+
+// BecknError converts SignValidationErr into a Beckn-compliant Error response.
+func (e *SignValidationErr) BecknError() *Error {
+	return &Error{
+		Code:    http.StatusText(http.StatusUnauthorized),
+		Message: "Signature Validation Error: " + e.Error(),
+	}
+}
+
+// BadReqErr represents an error related to a bad request.
+type BadReqErr struct {
+	error
+}
+
+// NewBadReqErr creates a new BadReqErr from an existing error.
+func NewBadReqErr(err error) *BadReqErr {
+	return &BadReqErr{err}
+}
+
+// NewBadReqErrf creates a new BadReqErr with a formatted message.
+func NewBadReqErrf(format string, a ...any) *BadReqErr {
+	return &BadReqErr{fmt.Errorf(format, a...)}
+}
+
+// BecknError converts BadReqErr into a Beckn-compliant Error response.
+func (e *BadReqErr) BecknError() *Error {
+	return &Error{
+		Code:    http.StatusText(http.StatusBadRequest),
+		Message: "BAD Request: " + e.Error(),
+	}
+}
+
+// NotFoundErr represents an error for a missing resource or endpoint.
+type NotFoundErr struct {
+	error
+}
+
+// NewNotFoundErr creates a new NotFoundErr from an existing error.
+func NewNotFoundErr(err error) *NotFoundErr {
+	return &NotFoundErr{err}
+}
+
+// NewNotFoundErrf creates a new NotFoundErr with a formatted message.
+func NewNotFoundErrf(format string, a ...any) *NotFoundErr {
+	return &NotFoundErr{fmt.Errorf(format, a...)}
+}
+
+// BecknError converts NotFoundErr into a Beckn-compliant Error response.
+func (e *NotFoundErr) BecknError() *Error {
+	return &Error{
+		Code:    http.StatusText(http.StatusNotFound),
+		Message: "Endpoint not found: " + e.Error(),
+	}
+}