@rivascva/dt-idl 1.1.77 → 1.1.78

package/go/log/log.go

@@ -6,23 +6,19 @@ import (
 	"log"
 	"maps"
 	"os"
-
-	"github.com/RivasCVA/dt-idl/go/utils"
 )
 
 type Logger interface {
 	// Info prints an info log message.
-	Info(m any)
+	Info(ctx context.Context, m any)
 	// Warn prints a warning log message.
-	Warn(m any)
+	Warn(ctx context.Context, m any)
 	// Error prints an error log message.
-	Error(m any)
+	Error(ctx context.Context, m any)
 	// Fatal prints an error log message and exits the program.
-	Fatal(m any)
+	Fatal(ctx context.Context, m any)
 	// With returns a new log with the given key-value pairs.
 	With(kvs ...any) Logger
-	// WithContext returns a new log with the given context.
-	WithContext(ctx context.Context) Logger
 }
 
 type Log struct {
@@ -42,20 +38,20 @@ func NewLog() *Log {
 	}
 }
 
-func (l *Log) Info(m any) {
-	l.info.Println(toJson(m, l.kvs, "info"))
+func (l *Log) Info(ctx context.Context, m any) {
+	l.info.Println(toJson(m, kvsWithContext(ctx, l.kvs), "info"))
 }
 
-func (l *Log) Warn(m any) {
-	l.warn.Println(toJson(m, l.kvs, "warn"))
+func (l *Log) Warn(ctx context.Context, m any) {
+	l.warn.Println(toJson(m, kvsWithContext(ctx, l.kvs), "warn"))
 }
 
-func (l *Log) Error(m any) {
-	l.error.Println(toJson(m, l.kvs, "error"))
+func (l *Log) Error(ctx context.Context, m any) {
+	l.error.Println(toJson(m, kvsWithContext(ctx, l.kvs), "error"))
 }
 
-func (l *Log) Fatal(m any) {
-	l.error.Fatal(toJson(m, l.kvs, "error"))
+func (l *Log) Fatal(ctx context.Context, m any) {
+	l.error.Fatal(toJson(m, kvsWithContext(ctx, l.kvs), "error"))
 }
 
 func (l *Log) With(kvs ...any) Logger {
@@ -81,28 +77,5 @@ func (l *Log) With(kvs ...any) Logger {
 	}
 }
 
-func (l *Log) WithContext(ctx context.Context) Logger {
-	// copy the existing key-value pairs into a new map
-	newkvs := make(map[string]any, len(l.kvs)+10)
-	maps.Copy(newkvs, l.kvs)
-
-	// add the user id to the key-value pairs
-	if userId, err := utils.GetUserIdFromContext(ctx); err == nil {
-		newkvs["userId"] = userId
-	}
-
-	// add the request path to the key-value pairs
-	if path, err := utils.GetPathFromContext(ctx); err == nil {
-		newkvs["path"] = path
-	}
-
-	return &Log{
-		kvs:   newkvs,
-		info:  l.info,
-		warn:  l.warn,
-		error: l.error,
-	}
-}
-
 //exhaustruct:ignore - check for interface implementation
 var _ Logger = &Log{}

package/go/log/utils.go

@@ -1,16 +1,21 @@
 package log
 
 import (
+	"context"
 	"encoding/json"
 	"maps"
 	"time"
+
+	"github.com/RivasCVA/dt-idl/go/utils"
 )
 
 // toJson converts the message and key-value pairs to a JSON string.
 func toJson(m any, kvs map[string]any, level string) string {
-	// copy the key-value pairs into a new map and add the message
-	out := make(map[string]any, len(kvs)+1)
+	// copy the key-value pairs into a new map
+	out := make(map[string]any, len(kvs)+3)
 	maps.Copy(out, kvs)
+
+	// add the message
 	out["msg"] = m
 
 	// add the log level
@@ -27,3 +32,22 @@ func toJson(m any, kvs map[string]any, level string) string {
 
 	return string(data)
 }
+
+// kvsWithContext returns a new kvs map with added context metadata.
+func kvsWithContext(ctx context.Context, kvs map[string]any) map[string]any {
+	// copy the existing key-value pairs into a new map
+	newkvs := make(map[string]any, len(kvs)+2)
+	maps.Copy(newkvs, kvs)
+
+	// add the user id to the key-value pairs
+	if userId, err := utils.GetUserIdFromContext(ctx); err == nil {
+		newkvs["userId"] = userId
+	}
+
+	// add the request path to the key-value pairs
+	if path, err := utils.GetPathFromContext(ctx); err == nil {
+		newkvs["path"] = path
+	}
+
+	return newkvs
+}

package/go/middlewares/middlewares.go

@@ -30,14 +30,14 @@ func GetAuthMiddleware(secret string) func(http.Handler) http.Handler {
 			authorizationHeader := r.Header.Get("Authorization")
 			arr := strings.Split(authorizationHeader, " ")
 			if len(arr) != 2 || arr[0] != "Bearer" {
-				write.ResponseWithError(w, http.StatusUnauthorized, "invalid authorization header")
+				write.ResponseWithError(r.Context(), w, http.StatusUnauthorized, "invalid authorization header")
 				return
 			}
 
 			// validate the token
 			token, err := jwt.ValidateToken(arr[1], secret)
 			if err != nil {
-				write.ResponseWithError(w, http.StatusUnauthorized, "invalid token")
+				write.ResponseWithError(r.Context(), w, http.StatusUnauthorized, "invalid token")
 				return
 			}
 

package/go/write/write.go

@@ -1,6 +1,7 @@
 package write
 
 import (
+	"context"
 	"encoding/json"
 	"net/http"
 
@@ -10,13 +11,13 @@ import (
 type Writer[T ~string] interface {
 	// Response writes a JSON response to the given response writer.
 	// The given data is converted to JSON. An error response is written if the marshal fails.
-	Response(w http.ResponseWriter, status int, data any)
+	Response(ctx context.Context, w http.ResponseWriter, status int, data any)
 	// ResponseWithError writes a JSON error response to the given response writer.
 	// The response is based on the shared Error schema.
-	ResponseWithError(w http.ResponseWriter, status int, message string)
+	ResponseWithError(ctx context.Context, w http.ResponseWriter, status int, message string)
 	// ResponseWithErrorCode writes a JSON error response with a specific code to the given response writer.
 	// The response is based on the shared Error schema.
-	ResponseWithErrorCode(w http.ResponseWriter, status int, code T, message string)
+	ResponseWithErrorCode(ctx context.Context, w http.ResponseWriter, status int, code T, message string)
 }
 
 type Write[T ~string] struct {
@@ -31,12 +32,12 @@ func NewWrite[T ~string](baseError T, log log.Logger) *Write[T] {
 	}
 }
 
-func (r *Write[T]) Response(w http.ResponseWriter, status int, data any) {
+func (r *Write[T]) Response(ctx context.Context, w http.ResponseWriter, status int, data any) {
 	// encode the given data object
 	out, err := json.Marshal(data)
 	if err != nil {
-		r.log.With("err", err).Error("failed to marshal the data")
-		r.ResponseWithError(w, http.StatusInternalServerError, "error encoding the data")
+		r.log.With("err", err).Error(ctx, "failed to marshal the data")
+		r.ResponseWithError(ctx, w, http.StatusInternalServerError, "error encoding the data")
 		return
 	}
 
@@ -44,15 +45,15 @@ func (r *Write[T]) Response(w http.ResponseWriter, status int, data any) {
 	w.WriteHeader(status)
 	_, err = w.Write(out)
 	if err != nil {
-		r.log.With("err", err).Fatal("failed to write the response")
+		r.log.With("err", err).Fatal(ctx, "failed to write the response")
 	}
 }
 
-func (r *Write[T]) ResponseWithError(w http.ResponseWriter, status int, message string) {
-	r.ResponseWithErrorCode(w, status, r.baseError, message)
+func (r *Write[T]) ResponseWithError(ctx context.Context, w http.ResponseWriter, status int, message string) {
+	r.ResponseWithErrorCode(ctx, w, status, r.baseError, message)
 }
 
-func (r *Write[T]) ResponseWithErrorCode(w http.ResponseWriter, status int, code T, message string) {
+func (r *Write[T]) ResponseWithErrorCode(ctx context.Context, w http.ResponseWriter, status int, code T, message string) {
 	// encode an error object with the given message
 	out, err := json.Marshal(Error[T]{
 		Status:  int64(status),
@@ -60,14 +61,14 @@ func (r *Write[T]) ResponseWithErrorCode(w http.ResponseWriter, status int, code
 		Message: message,
 	})
 	if err != nil {
-		r.log.With("err", err).Fatal("failed to marshal the error")
+		r.log.With("err", err).Fatal(ctx, "failed to marshal the error")
 	}
 
 	// write the data to the given writer
 	w.WriteHeader(status)
 	_, err = w.Write(out)
 	if err != nil {
-		r.log.With("err", err).Fatal("failed to write the response")
+		r.log.With("err", err).Fatal(ctx, "failed to write the response")
 	}
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rivascva/dt-idl",
-  "version": "1.1.77",
+  "version": "1.1.78",
   "description": "Dream Trade - Interface Definition Language",
   "main": "dist/index.cjs.js",
   "module": "dist/index.esm.js",