@rivascva/dt-idl 1.1.68 → 1.1.70

package/go/{utils/jwt → jwt}/jwt.go

@@ -6,7 +6,7 @@ import (
 	"github.com/golang-jwt/jwt/v5"
 )
 
-// Validates the given JWT token using the provided secret.
+// ValidateToken validates the given JWT token using the provided secret.
 func ValidateToken(token string, secret string) (*jwt.Token, error) {
 	// create a JWT parser with the HS256 signing method
 	parser := jwt.NewParser(jwt.WithValidMethods([]string{jwt.SigningMethodHS256.Alg()}))
@@ -14,7 +14,7 @@ func ValidateToken(token string, secret string) (*jwt.Token, error) {
 	// validate the JWT token
 	parsedToken, err := parser.Parse(token, func(t *jwt.Token) (any, error) { return []byte(secret), nil })
 	if err != nil {
-		return nil, fmt.Errorf("ValidateToken: unable to validate the JWT token: %w", err)
+		return nil, fmt.Errorf("unable to validate the JWT token: %w", err)
 	}
 
 	return parsedToken, nil

package/go/log/log.go

@@ -0,0 +1,88 @@
+package log
+
+import (
+	"fmt"
+	"log"
+	"maps"
+	"os"
+)
+
+type Logger interface {
+	// Info prints an info log message.
+	Info(m any)
+	// Warn prints a warning log message.
+	Warn(m any)
+	// Error prints an error log message.
+	Error(m any)
+	// Fatal prints an error log message and exits the program.
+	Fatal(m any)
+	// With returns a new log with the given key-value pairs.
+	With(kvs ...any) Logger
+}
+
+type Log struct {
+	kvs    map[string]any
+	prefix string
+	info   *log.Logger
+	warn   *log.Logger
+	error  *log.Logger
+}
+
+// NewLog creates a new log.
+func NewLog() *Log {
+	return NewLogWithPrefix("")
+}
+
+// NewLogWithPrefix creates a new log with a custom prefix.
+func NewLogWithPrefix(prefix string) *Log {
+	return &Log{
+		kvs:    make(map[string]any, 10),
+		prefix: prefix,
+		info:   log.New(os.Stdout, "[INFO] ", log.LstdFlags),
+		warn:   log.New(os.Stdout, "[WARN] ", log.LstdFlags),
+		error:  log.New(os.Stdout, "[ERROR] ", log.LstdFlags),
+	}
+}
+
+func (l *Log) Info(m any) {
+	l.info.Println(l.prefix, toJson(m, l.kvs))
+}
+
+func (l *Log) Warn(m any) {
+	l.warn.Println(l.prefix, toJson(m, l.kvs))
+}
+
+func (l *Log) Error(m any) {
+	l.error.Println(l.prefix, toJson(m, l.kvs))
+}
+
+func (l *Log) Fatal(m any) {
+	l.error.Fatal(l.prefix, toJson(m, l.kvs))
+}
+
+func (l *Log) With(kvs ...any) Logger {
+	// copy the existing key-value pairs into a new map
+	newkvs := make(map[string]any, len(l.kvs)+len(kvs))
+	maps.Copy(newkvs, l.kvs)
+
+	// add the new key-value pairs into the new map
+	for i := 0; i < len(kvs); i += 2 {
+		k := fmt.Sprintf("%v", kvs[i])
+		v := ""
+		if i+1 < len(kvs) {
+			v = fmt.Sprintf("%v", kvs[i+1])
+		}
+		newkvs[k] = v
+	}
+
+	return &Log{
+		kvs:    newkvs,
+		prefix: l.prefix,
+		info:   l.info,
+		warn:   l.warn,
+		error:  l.error,
+	}
+}
+
+//exhaustruct:ignore - check for interface implementation
+var _ Logger = &Log{}

package/go/log/utils.go

@@ -0,0 +1,22 @@
+package log
+
+import (
+	"encoding/json"
+	"maps"
+)
+
+// toJson converts the message and key-value pairs to a JSON string.
+func toJson(m any, kvs map[string]any) string {
+	// copy the key-value pairs into a new map and add the message
+	out := make(map[string]any, len(kvs)+1)
+	maps.Copy(out, kvs)
+	out["msg"] = m
+
+	// marshal the map to a JSON byte array
+	data, err := json.Marshal(out)
+	if err != nil {
+		return err.Error()
+	}
+
+	return string(data)
+}

package/go/{utils/middlewares → middlewares}/middlewares.go

@@ -6,16 +6,18 @@ import (
 	"slices"
 	"strings"
 
+	"github.com/RivasCVA/dt-idl/go/jwt"
+	"github.com/RivasCVA/dt-idl/go/log"
 	"github.com/RivasCVA/dt-idl/go/models"
-	"github.com/RivasCVA/dt-idl/go/utils/jwt"
-	"github.com/RivasCVA/dt-idl/go/utils/logger"
-	"github.com/RivasCVA/dt-idl/go/utils/responder"
+	"github.com/RivasCVA/dt-idl/go/write"
 )
 
-// Returns a middleware function that authenticates all requests except for the login endpoints.
+// GetAuthMiddleware returns a middleware function that authenticates all requests, except for the login endpoints.
 // It attaches the token to the request context.
 func GetAuthMiddleware(secret string) func(http.Handler) http.Handler {
-	responder := responder.NewStandardResponder(logger.NewConsoleLoggerWithPrefix("GetAuthMiddleware:"), "ERROR")
+	log := log.NewLog().With("method", "GetAuthMiddleware")
+	write := write.NewWrite("ERROR", log)
+
 	return func(next http.Handler) http.Handler {
 		return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 			// check if the request is a login endpoint
@@ -28,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" {
-				responder.WriteError(w, http.StatusUnauthorized, "invalid authorization header")
+				write.ResponseWithError(w, http.StatusUnauthorized, "invalid authorization header")
 				return
 			}
 
 			// validate the token
 			token, err := jwt.ValidateToken(arr[1], secret)
 			if err != nil {
-				responder.WriteError(w, http.StatusUnauthorized, "invalid token")
+				write.ResponseWithError(w, http.StatusUnauthorized, "invalid token")
 				return
 			}
 
@@ -48,7 +50,7 @@ func GetAuthMiddleware(secret string) func(http.Handler) http.Handler {
 	}
 }
 
-// Adds shared headers to all responses.
+// CommonHeaders adds shared headers to all responses.
 func CommonHeaders(next http.Handler) http.Handler {
 	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 		w.Header().Add("content-type", "application/json")

package/go/models/constants.go

@@ -1,7 +1,9 @@
 package models
 
-// ContextKey is the type used to define keys for the request context.
+// ContextKey is a type used to define keys for a request context.
 type ContextKey string
 
-// TokenKey is the key used to store the JWT token in the request context.
-const TokenKey = ContextKey("token")
+const (
+	// TokenKey is the key used to set/get the JWT token in the request context.
+	TokenKey = ContextKey("token")
+)

package/go/{utils/fetch/fetch.go → request/request.go}

@@ -1,4 +1,4 @@
-package fetch
+package request
 
 import (
 	"encoding/json"
@@ -6,9 +6,12 @@ import (
 	"net/http"
 )
 
-// Makes a GET request to the given url.
-//
-// Parses the JSON-encoded response and stores the result into v.
+type Response struct {
+	StatusCode int
+}
+
+// Get makes a GET request to the given url.
+// It parses the JSON-encoded response and stores the result into v.
 func Get(url string, v any) (*Response, error) {
 	// make the GET request
 	resp, err := http.Get(url)

package/go/utils/context.go

@@ -0,0 +1,17 @@
+package utils
+
+import (
+	"context"
+
+	"github.com/RivasCVA/dt-idl/go/models"
+	"github.com/golang-jwt/jwt/v5"
+)
+
+// GetTokenFromContext retrieves the JWT token from the given context.
+func GetTokenFromContext(ctx context.Context) *jwt.Token {
+	token, ok := ctx.Value(models.TokenKey).(*jwt.Token)
+	if !ok {
+		return nil
+	}
+	return token
+}

package/go/utils/maps.go

@@ -0,0 +1,10 @@
+package utils
+
+// MapKeys returns the keys of the given map as a slice.
+func MapKeys[K ~string, V any](m map[K]V) []K {
+	keys := make([]K, 0, len(m))
+	for k := range m {
+		keys = append(keys, k)
+	}
+	return keys
+}

package/go/utils/{url/url.go → url.go}

@@ -1,14 +1,13 @@
-package url
+package utils
 
 import (
 	"fmt"
 	"net/url"
 )
 
-// Builds a url string from the given base and path.
-//
-// Encodes any given query parameters into the url.
-func Build(base string, path string, params map[string]any) (string, error) {
+// BuildUrl builds a url string from the given base and path.
+// It encodes any given query parameters into the url.
+func BuildUrl(base string, path string, params map[string]any) (string, error) {
 	// parse the combined base and path
 	url, err := url.Parse(base + path)
 	if err != nil {

package/go/{utils/responder → write}/models.go

@@ -1,8 +1,7 @@
-package responder
+package write
 
-// Base error struct.
-//
-// The struct should match the base "Error" schema in all services.
+// Error is a shared error schema.
+// The struct should match the base Error schema in all services.
 type Error[T ~string] struct {
 	Status  int64  `json:"status"`
 	Code    T      `json:"code"`

package/go/write/write.go

@@ -0,0 +1,75 @@
+package write
+
+import (
+	"encoding/json"
+	"net/http"
+
+	"github.com/RivasCVA/dt-idl/go/log"
+)
+
+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)
+	// 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)
+	// 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)
+}
+
+type Write[T ~string] struct {
+	baseError T
+	log       log.Logger
+}
+
+func NewWrite[T ~string](baseError T, log log.Logger) *Write[T] {
+	return &Write[T]{
+		baseError: baseError,
+		log:       log,
+	}
+}
+
+func (r *Write[T]) Response(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")
+		return
+	}
+
+	// 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")
+	}
+}
+
+func (r *Write[T]) ResponseWithError(w http.ResponseWriter, status int, message string) {
+	r.ResponseWithErrorCode(w, status, r.baseError, message)
+}
+
+func (r *Write[T]) ResponseWithErrorCode(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),
+		Code:    code,
+		Message: message,
+	})
+	if err != nil {
+		r.log.With("err", err).Fatal("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")
+	}
+}
+
+//exhaustruct:ignore - check for interface implementation
+var _ Writer[string] = &Write[string]{}

package/package.json

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

package/go/utils/fetch/models.go

@@ -1,6 +0,0 @@
-package fetch
-
-// Base fetch response struct.
-type Response struct {
-	StatusCode int
-}

package/go/utils/logger/logger.go

@@ -1,56 +0,0 @@
-package logger
-
-import (
-	"fmt"
-	"log"
-	"os"
-)
-
-type Logger interface {
-	// Prints an info log message.
-	Info(v ...any)
-	// Prints a warning log message.
-	Warn(v ...any)
-	// Prints an error log message.
-	Error(v ...any)
-	// Prints an error log message and exits the program.
-	Fatal(v ...any)
-}
-
-type ConsoleLogger struct {
-	prefix string
-	info   *log.Logger
-	warn   *log.Logger
-	error  *log.Logger
-}
-
-// Creates a new console logger.
-func NewConsoleLogger() *ConsoleLogger {
-	return NewConsoleLoggerWithPrefix("")
-}
-
-// Creates a new logger with a custom prefix.
-func NewConsoleLoggerWithPrefix(prefix string) *ConsoleLogger {
-	return &ConsoleLogger{
-		prefix: prefix,
-		info:   log.New(os.Stdout, "[INFO] ", log.LstdFlags),
-		warn:   log.New(os.Stdout, "[WARN] ", log.LstdFlags),
-		error:  log.New(os.Stdout, "[ERROR] ", log.LstdFlags),
-	}
-}
-
-func (l *ConsoleLogger) Info(v ...any) {
-	l.info.Println(l.prefix, fmt.Sprint(v...))
-}
-
-func (l *ConsoleLogger) Warn(v ...any) {
-	l.warn.Println(l.prefix, fmt.Sprint(v...))
-}
-
-func (l *ConsoleLogger) Error(v ...any) {
-	l.error.Println(l.prefix, fmt.Sprint(v...))
-}
-
-func (l *ConsoleLogger) Fatal(v ...any) {
-	l.error.Fatal(l.prefix, fmt.Sprint(v...))
-}

package/go/utils/maps/maps.go

@@ -1,10 +0,0 @@
-package maps
-
-// Returns the keys of the given map as a slice.
-func Keys[K ~string, V any](m map[K]V) []K {
-	keys := make([]K, 0, len(m))
-	for k := range m {
-		keys = append(keys, k)
-	}
-	return keys
-}

package/go/utils/responder/responder.go

@@ -1,76 +0,0 @@
-package responder
-
-import (
-	"encoding/json"
-	"fmt"
-	"net/http"
-
-	"github.com/RivasCVA/dt-idl/go/utils/logger"
-)
-
-type Responder[T ~string] interface {
-	// 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.
-	Write(w http.ResponseWriter, status int, data any)
-	// Writes a JSON error response to the given response writer.
-	//
-	// The response is based on the shared "Error" schema.
-	WriteError(w http.ResponseWriter, status int, message string)
-	// Writes a JSON error response with a specific code to the given response writer.
-	//
-	// The response is based on the shared "Error" schema.
-	WriteErrorWithCode(w http.ResponseWriter, status int, code T, message string)
-}
-
-type StandardResponder[T ~string] struct {
-	logger      logger.Logger
-	defaultCode T
-}
-
-func NewStandardResponder[T ~string](logger logger.Logger, defaultCode T) *StandardResponder[T] {
-	return &StandardResponder[T]{
-		logger:      logger,
-		defaultCode: defaultCode,
-	}
-}
-
-func (r *StandardResponder[T]) Write(w http.ResponseWriter, status int, data any) {
-	// encode the given data object
-	out, err := json.Marshal(data)
-	if err != nil {
-		r.logger.Error(fmt.Errorf("Write: failed to marshal the data: %w", err))
-		r.WriteError(w, http.StatusInternalServerError, "error encoding the data")
-		return
-	}
-
-	// write the data to the given writer
-	w.WriteHeader(status)
-	_, err = w.Write(out)
-	if err != nil {
-		r.logger.Fatal(fmt.Errorf("Write: failed to write a response: %w", err))
-	}
-}
-
-func (r *StandardResponder[T]) WriteError(w http.ResponseWriter, status int, message string) {
-	r.WriteErrorWithCode(w, status, r.defaultCode, message)
-}
-
-func (r *StandardResponder[T]) WriteErrorWithCode(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),
-		Code:    code,
-		Message: message,
-	})
-	if err != nil {
-		r.logger.Fatal(fmt.Errorf("WriteErrorWithCode: failed to marshal the error: %w", err))
-	}
-
-	// write the data to the given writer
-	w.WriteHeader(status)
-	_, err = w.Write(out)
-	if err != nil {
-		r.logger.Fatal(fmt.Errorf("WriteErrorWithCode: failed to write a response: %w", err))
-	}
-}