initial commit

pkg/array/aggregate.go

@@ -0,0 +1,26 @@
+package array
+
+func Chunk[T interface{}](arr []T, chunkSize int) [][]T {
+	var chunkedArray [][]T
+
+	for i := 0; i < len(arr); i += chunkSize {
+		end := i + chunkSize
+
+		if end > len(arr) {
+			end = len(arr)
+		}
+
+		chunkedArray = append(chunkedArray, arr[i:end])
+	}
+
+	return chunkedArray
+}
+
+func Sum[T any, N Numbers](arr []T, selector func(val T) N) N {
+	var summed N
+	for i := 0; i < len(arr); i++ {
+		r := selector(arr[i])
+		summed += r
+	}
+	return summed
+}

pkg/array/aggregate_test.go

@@ -0,0 +1,30 @@
+package array
+
+import (
+	"github.com/stretchr/testify/assert"
+	"testing"
+)
+
+func TestSum_WithNumberArray_ShouldBeAsExpected(t *testing.T) {
+	// Arrange
+	arr := []int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
+	// Act
+	r := Sum(arr, func(val int) int {
+		return val
+	})
+	// Assert
+	const expected = 55
+	assert.True(t, r == expected)
+}
+
+func TestSum_WithStructArray_ShouldBeAsExpected(t *testing.T) {
+	// Arrange
+	arr := []struct{ d float64 }{{d: 0.1}, {d: 1.5}, {d: 0.4}, {d: 2.5}, {d: 5.521}}
+	// Act
+	r := Sum(arr, func(val struct{ d float64 }) float64 {
+		return val.d
+	})
+	// Assert
+	const expected = 10.021
+	assert.True(t, r == expected)
+}

pkg/array/any.go

@@ -0,0 +1,39 @@
+package array
+
+func All[T any](arr []T, predicate func(val T) bool) bool {
+	for i := 0; i < len(arr); i++ {
+		if !predicate(arr[i]) {
+			return false
+		}
+	}
+	return true
+}
+
+// Any returns true if any element in the array satisfies the predicate; otherwise, it returns false.
+func Any[TIn any](arr []TIn, predicate func(val TIn) bool) bool {
+	for i := 0; i < len(arr); i++ {
+		if predicate(arr[i]) {
+			return true
+		}
+	}
+	return false
+}
+
+func AnyError[TIn any](arr []TIn, predicate func(val TIn) error) error {
+	for i := 0; i < len(arr); i++ {
+		if err := predicate(arr[i]); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+// Contains checks if a slice contains a specific element.
+func Contains[T comparable](slice []T, element T) bool {
+	for i := 0; i < len(slice); i++ {
+		if slice[i] == element {
+			return true
+		}
+	}
+	return false
+}

pkg/array/diff.go

@@ -0,0 +1,75 @@
+package array
+
+func Diff[T comparable](slice1, slice2 []T) []T {
+	var result []T
+
+	elementsMap := make(map[T]bool)
+	for _, v := range slice2 {
+		elementsMap[v] = true
+	}
+
+	for _, v := range slice1 {
+		if !elementsMap[v] {
+			result = append(result, v)
+		}
+	}
+
+	return result
+}
+
+func MapDiff[T comparable](slice1, slice2 []T) []T {
+	var result []T
+
+	arr1elementsMap := make(map[T]int)
+	for _, v := range slice1 {
+		arr1elementsMap[v] += 1
+	}
+
+	arr2elementsMap := make(map[T]int)
+	for _, v := range slice2 {
+		arr2elementsMap[v] += 1
+	}
+
+	for key, count1 := range arr1elementsMap {
+		if count2, ok := arr2elementsMap[key]; !ok || count2 != count1 {
+			result = append(result, key)
+		}
+	}
+
+	return result
+}
+
+// DiffByKeyAndValue returns the elements from slice1 that do not have
+// corresponding elements in slice2 based on a key and a comparison function.
+// T1 and T2 are the types of the elements in slice1 and slice2 respectively.
+// K is the type of the key used for comparison.
+func DiffByKeyAndValue[T1 any, T2 any, K comparable](
+	slice1 []T1,
+	slice2 []T2,
+	getKeyFromSlice1 func(T1) K,
+	getKeyFromSlice2 func(T2) K,
+	compare func(T1, T2) bool,
+) []T1 {
+	// Create a map to index elements of slice2 by their keys
+	indexedSlice2 := make(map[K]T2)
+	for _, elementFromSlice2 := range slice2 {
+		key := getKeyFromSlice2(elementFromSlice2)
+		indexedSlice2[key] = elementFromSlice2
+	}
+
+	// Initialize a slice to hold the elements that are different
+	var differingElements []T1
+
+	// Iterate over slice1 and find elements that are not in slice2
+	for _, elementFromSlice1 := range slice1 {
+		key := getKeyFromSlice1(elementFromSlice1)
+
+		// Check if the key exists in the indexed slice2
+		if correspondingElementFromSlice2, exists := indexedSlice2[key]; !exists || !compare(elementFromSlice1, correspondingElementFromSlice2) {
+			// If it doesn't exist or the comparison fails, add to the result
+			differingElements = append(differingElements, elementFromSlice1)
+		}
+	}
+
+	return differingElements
+}

pkg/array/empty.go

@@ -0,0 +1,5 @@
+package array
+
+func IsEmpty[TIn any](arr []TIn) bool {
+	return arr == nil || len(arr) == 0
+}

pkg/array/enumerator.go

@@ -0,0 +1,7 @@
+package array
+
+type Enumerator[T any] interface {
+	Next() bool
+	Current() (*T, error)
+	Destroy() error
+}

pkg/array/example_test.go

@@ -0,0 +1,289 @@
+package array_test
+
+import (
+	"errors"
+	"fmt"
+	"sort"
+	"strings"
+
+	"base/pkg/array"
+)
+
+// Product represents a product in an base system
+type Product struct {
+	ID       int
+	Name     string
+	Price    float64
+	Category string
+}
+
+// ProductDTO is a data transfer object for Product
+type ProductDTO struct {
+	ID        int    `json:"id"`
+	Name      string `json:"name"`
+	PriceUSD  string `json:"price_usd"`
+	Available bool   `json:"available"`
+}
+
+// base represents a store's base
+type base struct {
+	StoreID   int
+	StoreName string
+	Products  []Product
+}
+
+// Review represents a customer review
+type Review struct {
+	ProductID int
+	Rating    int
+	Comment   string
+}
+
+func Example_map() {
+	// Create a slice of Product structs
+	products := []Product{
+		{ID: 1, Name: "Laptop", Price: 999.99, Category: "Electronics"},
+		{ID: 2, Name: "Headphones", Price: 99.99, Category: "Electronics"},
+		{ID: 3, Name: "Keyboard", Price: 49.99, Category: "Accessories"},
+	}
+
+	// Use Map to transform Product structs to ProductDTO structs
+	productDTOs := array.Map(products, func(p Product, i int) ProductDTO {
+		return ProductDTO{
+			ID:        p.ID,
+			Name:      p.Name,
+			PriceUSD:  fmt.Sprintf("$%.2f", p.Price),
+			Available: p.Price > 0,
+		}
+	})
+
+	// Print the result
+	for _, dto := range productDTOs {
+		fmt.Printf("Product %d: %s - %s\n", dto.ID, dto.Name, dto.PriceUSD)
+	}
+
+	// Output:
+	// Product 1: Laptop - $999.99
+	// Product 2: Headphones - $99.99
+	// Product 3: Keyboard - $49.99
+}
+
+func Example_mapWithError() {
+	// Create a slice of Product structs
+	products := []Product{
+		{ID: 1, Name: "Laptop", Price: 999.99, Category: "Electronics"},
+		{ID: 2, Name: "Headphones", Price: 99.99, Category: "Electronics"},
+		{ID: 3, Name: "Keyboard", Price: 49.99, Category: "Accessories"},
+	}
+
+	// Use MapWithError to transform Product structs to discounted products,
+	// but only if the discount can be applied
+	discountedProducts, err := array.MapWithError(products, func(p Product, i int) (*Product, error) {
+		// For this example, we'll say we can't discount items under $50
+		if p.Price < 50.0 {
+			return nil, errors.New("cannot discount items under $50")
+		}
+
+		// Create a new product with 10% discount
+		discounted := p
+		discounted.Price = p.Price * 0.9
+		return &discounted, nil
+	})
+
+	// Check for errors
+	if err != nil {
+		fmt.Println("Error:", err)
+	} else {
+		// Print the result
+		for _, p := range discountedProducts {
+			fmt.Printf("Discounted %s: $%.2f\n", p.Name, p.Price)
+		}
+	}
+
+	// Try with products that all meet the criteria
+	expensiveProducts := []Product{
+		{ID: 1, Name: "Laptop", Price: 999.99, Category: "Electronics"},
+		{ID: 2, Name: "Smartphone", Price: 699.99, Category: "Electronics"},
+	}
+
+	discountedProducts, err = array.MapWithError(expensiveProducts, func(p Product, i int) (*Product, error) {
+		// All these products can be discounted
+		discounted := p
+		discounted.Price = p.Price * 0.9
+		return &discounted, nil
+	})
+
+	// Print the successful result
+	if err != nil {
+		fmt.Println("Error:", err)
+	} else {
+		for _, p := range discountedProducts {
+			fmt.Printf("Discounted %s: $%.2f\n", p.Name, p.Price)
+		}
+	}
+
+	// Output:
+	// Error: cannot discount items under $50
+	// Discounted Laptop: $899.99
+	// Discounted Smartphone: $629.99
+}
+
+func Example_mapD() {
+	// Create a map of store inventories
+	storeInventories := map[string]base{
+		"NY": {
+			StoreID:   1,
+			StoreName: "New York Store",
+			Products: []Product{
+				{ID: 1, Name: "Laptop", Price: 999.99, Category: "Electronics"},
+				{ID: 2, Name: "Headphones", Price: 99.99, Category: "Electronics"},
+			},
+		},
+		"LA": {
+			StoreID:   2,
+			StoreName: "Los Angeles Store",
+			Products: []Product{
+				{ID: 1, Name: "Laptop", Price: 1099.99, Category: "Electronics"},
+				{ID: 3, Name: "Keyboard", Price: 49.99, Category: "Accessories"},
+			},
+		},
+	}
+
+	// Use MapD to extract and format store information
+	storeInfos := array.MapD(storeInventories, func(inv base, location string) string {
+		return fmt.Sprintf("%s (ID: %d) - %s - %d products",
+			inv.StoreName, inv.StoreID, location, len(inv.Products))
+	})
+
+	// Sort the results for consistent output
+	sort.Strings(storeInfos)
+
+	// Print the result
+	for _, info := range storeInfos {
+		fmt.Println(info)
+	}
+
+	// Output:
+	// Los Angeles Store (ID: 2) - LA - 2 products
+	// New York Store (ID: 1) - NY - 2 products
+}
+
+func Example_forEach() {
+	// Create a slice of Product structs
+	products := []Product{
+		{ID: 1, Name: "Laptop", Price: 999.99, Category: "Electronics"},
+		{ID: 2, Name: "Headphones", Price: 99.99, Category: "Electronics"},
+		{ID: 3, Name: "Keyboard", Price: 49.99, Category: "Accessories"},
+	}
+
+	// Use ForEach to apply a 10% discount to all products
+	array.ForEach(products, func(p *Product, i int) {
+		p.Price = p.Price * 0.9
+	})
+
+	// Print the result
+	for _, p := range products {
+		fmt.Printf("%s: $%.2f\n", p.Name, p.Price)
+	}
+
+	// Output:
+	// Laptop: $899.99
+	// Headphones: $89.99
+	// Keyboard: $44.99
+}
+
+func Example_mapMany() {
+	// Create a slice of base structs
+	stores := []base{
+		{
+			StoreID:   1,
+			StoreName: "New York Store",
+			Products: []Product{
+				{ID: 1, Name: "Laptop", Price: 999.99, Category: "Electronics"},
+				{ID: 2, Name: "Headphones", Price: 99.99, Category: "Electronics"},
+			},
+		},
+		{
+			StoreID:   2,
+			StoreName: "Los Angeles Store",
+			Products: []Product{
+				{ID: 1, Name: "Laptop", Price: 1099.99, Category: "Electronics"},
+				{ID: 3, Name: "Keyboard", Price: 49.99, Category: "Accessories"},
+			},
+		},
+	}
+
+	// Use MapMany to flatten the store inventories into a list of product information
+	// but only include products priced over $100
+	productInfos := array.MapMany(stores,
+		func(store base) []Product {
+			return store.Products
+		},
+		func(store base, product Product) *string {
+			if product.Price < 100 {
+				return nil // Skip products under $100
+			}
+			info := fmt.Sprintf("%s - %s - $%.2f",
+				store.StoreName, product.Name, product.Price)
+			return &info
+		})
+
+	// Sort for consistent output
+	sort.Strings(productInfos)
+
+	// Print the result
+	for _, info := range productInfos {
+		fmt.Println(info)
+	}
+
+	// Output:
+	// Los Angeles Store - Laptop - $1099.99
+	// New York Store - Laptop - $999.99
+}
+
+func Example_mapManyD() {
+	// Create a map of store inventories
+	storeInventories := map[string]base{
+		"NY": {
+			StoreID:   1,
+			StoreName: "New York Store",
+			Products: []Product{
+				{ID: 1, Name: "Laptop", Price: 999.99, Category: "Electronics"},
+				{ID: 2, Name: "Headphones", Price: 99.99, Category: "Electronics"},
+			},
+		},
+		"LA": {
+			StoreID:   2,
+			StoreName: "Los Angeles Store",
+			Products: []Product{
+				{ID: 1, Name: "Laptop", Price: 1099.99, Category: "Electronics"},
+				{ID: 3, Name: "Keyboard", Price: 49.99, Category: "Accessories"},
+			},
+		},
+	}
+
+	// Use MapManyD to flatten the store inventories into a list of product names
+	productNames := array.MapManyD(storeInventories,
+		func(base base) []Product {
+			return base.Products
+		},
+		func(product Product) string {
+			return strings.ToUpper(product.Name)
+		})
+
+	// Sort for consistent output
+	sort.Strings(productNames)
+
+	// Print the result
+	fmt.Println("All product names (uppercase):")
+	for _, name := range productNames {
+		fmt.Println(name)
+	}
+
+	// Output:
+	// All product names (uppercase):
+	// HEADPHONES
+	// KEYBOARD
+	// LAPTOP
+	// LAPTOP
+}

pkg/array/find.go

@@ -0,0 +1,20 @@
+package array
+
+func Find[TIn any](arr []TIn, predicate func(val TIn) bool) *TIn {
+	for i := range arr {
+		if predicate(arr[i]) {
+			return &arr[i]
+		}
+	}
+	return nil
+}
+
+func Filter[TIn any](arr []TIn, predicate func(val *TIn) bool) []TIn {
+	var r []TIn
+	for i := range arr {
+		if predicate(&arr[i]) {
+			r = append(r, arr[i])
+		}
+	}
+	return r
+}

pkg/array/map.go

@@ -0,0 +1,188 @@
+package array
+
+// MapWithError transforms each element in the input slice to a new type, with error handling.
+//
+// It applies the selector function to each element in the input slice and its index.
+// If the selector function returns an error for any element, the function immediately
+// returns that error and a nil slice. Otherwise, it returns a new slice containing
+// all transformed elements and nil error.
+//
+// Generic parameters:
+//   - TIn: The type of elements in the input slice
+//   - TOut: The type of elements in the output slice
+//
+// Parameters:
+//   - arr: The input slice to transform
+//   - selector: A function that takes an element and its index, returning a pointer to
+//     the transformed value and an error
+//
+// Returns:
+//   - A slice of transformed elements
+//   - An error if the transformation failed for any element
+func MapWithError[TIn any, TOut any](arr []TIn, selector func(val TIn, index int) (*TOut, error)) ([]TOut, error) {
+	var output []TOut
+	for i := range arr {
+		out, err := selector(arr[i], i)
+		if err != nil {
+			return nil, err
+		}
+		output = append(output, *out)
+	}
+	return output, nil
+}
+
+// Map transforms each element in the input slice to a new type.
+//
+// It applies the selector function to each element in the input slice and its index,
+// returning a new slice containing all transformed elements.
+//
+// Generic parameters:
+//   - TIn: The type of elements in the input slice
+//   - TOut: The type of elements in the output slice
+//
+// Parameters:
+//   - arr: The input slice to transform
+//   - selector: A function that takes an element and its index, returning the transformed value
+//
+// Returns:
+//   - A slice of transformed elements
+func Map[TIn any, TOut any](arr []TIn, selector func(val TIn, index int) TOut) []TOut {
+	var output []TOut
+	for i := range arr {
+		out := selector(arr[i], i)
+		output = append(output, out)
+	}
+	return output
+}
+
+// MapD transforms each value in a map to an element in a slice.
+//
+// It applies the selector function to each value and key in the input map,
+// returning a slice containing all transformed values.
+//
+// Generic parameters:
+//   - TKey: The type of keys in the input map (must be comparable)
+//   - TIn: The type of values in the input map
+//   - TOut: The type of elements in the output slice
+//
+// Parameters:
+//   - m: The input map to transform
+//   - selector: A function that takes a value and its key, returning the transformed value
+//
+// Returns:
+//   - A slice of transformed values
+func MapD[TKey comparable, TIn any, TOut any](m map[TKey]TIn, selector func(val TIn, key TKey) TOut) []TOut {
+	var output []TOut
+	for i := range m {
+		out := selector(m[i], i)
+		output = append(output, out)
+	}
+	return output
+}
+
+// ForEach applies a function to each element in the input slice.
+//
+// Unlike Map, ForEach modifies elements in place by providing a pointer to each element.
+// This function does not return a new slice.
+//
+// Generic parameters:
+//   - TIn: The type of elements in the input slice
+//
+// Parameters:
+//   - arr: The input slice whose elements will be processed
+//   - selector: A function that takes a pointer to an element and its index
+func ForEach[TIn any](arr []TIn, selector func(val *TIn, index int)) {
+	for i := 0; i < len(arr); i++ {
+		selector(&arr[i], i)
+	}
+}
+
+// MapMany transforms and flattens a nested collection structure.
+//
+// It first applies the collectionSelector to each element in the input slice to produce
+// an inner collection. Then it applies the resultSelector to each inner element along with
+// the original element, flattening the result into a single output slice. If resultSelector
+// returns nil for any element, that element is skipped in the output.
+//
+// Generic parameters:
+//   - TIn: The type of elements in the input slice
+//   - TC: The type of elements in the inner collections
+//   - TOut: The type of elements in the output slice
+//
+// Parameters:
+//   - m: The input slice to transform
+//   - collectionSelector: A function that produces an inner collection from each input element
+//   - resultSelector: A function that transforms each inner element along with its parent element
+//
+// Returns:
+//   - A flattened slice of transformed elements
+func MapMany[TIn any, TC any, TOut any](m []TIn, collectionSelector func(TIn) []TC, resultSelector func(TIn, TC) *TOut) []TOut {
+	var output []TOut
+
+	for i := range m {
+		out := collectionSelector(m[i])
+		for _, v := range out {
+			result := resultSelector(m[i], v)
+			if result == nil {
+				continue
+			}
+			output = append(output, *result)
+		}
+	}
+	return output
+}
+
+// MapManyD transforms and flattens values from a map.
+//
+// It first applies the collectionSelector to each value in the input map to produce
+// an inner collection. Then it applies the resultSelector to each inner element,
+// flattening the results into a single output slice.
+//
+// Generic parameters:
+//   - TKey: The type of keys in the input map (must be comparable)
+//   - TIn: The type of values in the input map
+//   - TC: The type of elements in the inner collections
+//   - TOut: The type of elements in the output slice
+//
+// Parameters:
+//   - m: The input map to transform
+//   - collectionSelector: A function that produces an inner collection from each input value
+//   - resultSelector: A function that transforms each inner element
+//
+// Returns:
+//   - A flattened slice of transformed elements
+func MapManyD[TKey comparable, TIn any, TC any, TOut any](m map[TKey]TIn, collectionSelector func(TIn) []TC, resultSelector func(TC) TOut) []TOut {
+	var output []TOut
+
+	for i := range m {
+		out := collectionSelector(m[i])
+		for _, v := range out {
+			output = append(output, resultSelector(v))
+		}
+	}
+	return output
+}
+
+// ToMap converts a slice of items into a map using the provided key and value selectors.
+// TKey is the type of the keys in the resulting map, TIn is the type of items in the input slice,
+// and TOut is the type of the values in the resulting map.
+func ToMap[TKey comparable, TIn any, TOut any](
+	items []TIn,
+	keySelector func(TIn) TKey,
+	valueSelector func(TIn) TOut,
+) map[TKey]TOut {
+	// Create a map with an initial capacity equal to the length of the input slice
+	resultMap := make(map[TKey]TOut, len(items))
+
+	// Iterate through each item in the slice
+	for _, item := range items {
+		// Get the key and value using the provided selectors
+		key := keySelector(item)
+		value := valueSelector(item)
+
+		// Store the key-value pair in the result map
+		resultMap[key] = value
+	}
+
+	return resultMap
+}

pkg/array/map_test.go

@@ -0,0 +1,362 @@
+package array
+
+import (
+	"errors"
+	"reflect"
+	"testing"
+)
+
+func TestMapWithError(t *testing.T) {
+	t.Run("success case", func(t *testing.T) {
+		// Arrange
+		input := []int{1, 2, 3}
+		expected := []string{"1", "2", "3"}
+
+		// Act
+		result, err := MapWithError(input, func(val int, index int) (*string, error) {
+			str := string(rune(val + '0'))
+			return &str, nil
+		})
+
+		// Assert
+		if err != nil {
+			t.Errorf("Expected no error, got %v", err)
+		}
+		if !reflect.DeepEqual(result, expected) {
+			t.Errorf("Expected %v, got %v", expected, result)
+		}
+	})
+
+	t.Run("error case", func(t *testing.T) {
+		// Arrange
+		input := []int{1, 2, 3}
+		testErr := errors.New("test error")
+
+		// Act
+		result, err := MapWithError(input, func(val int, index int) (*string, error) {
+			if val == 2 {
+				return nil, testErr
+			}
+			str := string(rune(val + '0'))
+			return &str, nil
+		})
+
+		// Assert
+		if err != testErr {
+			t.Errorf("Expected error %v, got %v", testErr, err)
+		}
+		if result != nil {
+			t.Errorf("Expected nil result, got %v", result)
+		}
+	})
+
+	t.Run("empty array", func(t *testing.T) {
+		// Arrange
+		var input []int
+
+		// Act
+		result, err := MapWithError(input, func(val int, index int) (*string, error) {
+			str := string(rune(val + '0'))
+			return &str, nil
+		})
+
+		// Assert
+		if err != nil {
+			t.Errorf("Expected no error, got %v", err)
+		}
+		if len(result) != 0 {
+			t.Errorf("Expected empty result, got %v", result)
+		}
+	})
+}
+
+func TestMap(t *testing.T) {
+	t.Run("basic transformation", func(t *testing.T) {
+		// Arrange
+		input := []int{1, 2, 3}
+		expected := []string{"1", "2", "3"}
+
+		// Act
+		result := Map(input, func(val int, index int) string {
+			return string(rune(val + '0'))
+		})
+
+		// Assert
+		if !reflect.DeepEqual(result, expected) {
+			t.Errorf("Expected %v, got %v", expected, result)
+		}
+	})
+
+	t.Run("use index in transformation", func(t *testing.T) {
+		// Arrange
+		input := []string{"a", "b", "c"}
+		expected := []string{"a0", "b1", "c2"}
+
+		// Act
+		result := Map(input, func(val string, index int) string {
+			return val + string(rune(index+'0'))
+		})
+
+		// Assert
+		if !reflect.DeepEqual(result, expected) {
+			t.Errorf("Expected %v, got %v", expected, result)
+		}
+	})
+
+	t.Run("empty array", func(t *testing.T) {
+		// Arrange
+		var input []int
+
+		// Act
+		result := Map(input, func(val int, index int) string {
+			return string(rune(val + '0'))
+		})
+
+		// Assert
+		if len(result) != 0 {
+			t.Errorf("Expected empty result, got %v", result)
+		}
+	})
+}
+
+func TestMapD(t *testing.T) {
+	t.Run("map dictionary to array", func(t *testing.T) {
+		// Arrange
+		input := map[string]int{
+			"a": 1,
+			"b": 2,
+			"c": 3,
+		}
+
+		// Act
+		result := MapD(input, func(val int, key string) string {
+			return key + string(rune(val+'0'))
+		})
+
+		// Assert
+		// Since map iteration order is not guaranteed, we check that all expected elements are in the result
+		expectedElements := []string{"a1", "b2", "c3"}
+		if len(result) != len(expectedElements) {
+			t.Errorf("Expected result length %d, got %d", len(expectedElements), len(result))
+		}
+
+		resultMap := make(map[string]bool)
+		for _, v := range result {
+			resultMap[v] = true
+		}
+
+		for _, expected := range expectedElements {
+			if !resultMap[expected] {
+				t.Errorf("Expected result to contain %s, but it doesn't", expected)
+			}
+		}
+	})
+
+	t.Run("empty map", func(t *testing.T) {
+		// Arrange
+		input := map[string]int{}
+
+		// Act
+		result := MapD(input, func(val int, key string) string {
+			return key + string(rune(val+'0'))
+		})
+
+		// Assert
+		if len(result) != 0 {
+			t.Errorf("Expected empty result, got %v", result)
+		}
+	})
+}
+
+func TestForEach(t *testing.T) {
+	t.Run("modify array in place", func(t *testing.T) {
+		// Arrange
+		input := []int{1, 2, 3}
+		expected := []int{2, 3, 4}
+
+		// Act
+		ForEach(input, func(val *int, index int) {
+			*val += 1
+		})
+
+		// Assert
+		if !reflect.DeepEqual(input, expected) {
+			t.Errorf("Expected %v, got %v", expected, input)
+		}
+	})
+
+	t.Run("use index in modification", func(t *testing.T) {
+		// Arrange
+		input := []int{1, 2, 3}
+		expected := []int{1, 3, 5}
+
+		// Act
+		ForEach(input, func(val *int, index int) {
+			*val = *val + index
+		})
+
+		// Assert
+		if !reflect.DeepEqual(input, expected) {
+			t.Errorf("Expected %v, got %v", expected, input)
+		}
+	})
+
+	t.Run("empty array", func(t *testing.T) {
+		// Arrange
+		var input []int
+		callCount := 0
+
+		// Act
+		ForEach(input, func(val *int, index int) {
+			callCount++
+		})
+
+		// Assert
+		if callCount != 0 {
+			t.Errorf("Expected callback not to be called, but it was called %d times", callCount)
+		}
+	})
+}
+
+func TestMapMany(t *testing.T) {
+	t.Run("basic flat mapping", func(t *testing.T) {
+		// Arrange
+		input := []int{1, 2}
+		expected := []string{"1a", "1b", "2a", "2b"}
+
+		// Act
+		result := MapMany(input,
+			func(i int) []string {
+				return []string{"a", "b"}
+			},
+			func(i int, s string) *string {
+				res := string(rune(i+'0')) + s
+				return &res
+			})
+
+		// Assert
+		if !reflect.DeepEqual(result, expected) {
+			t.Errorf("Expected %v, got %v", expected, result)
+		}
+	})
+
+	t.Run("with nil results", func(t *testing.T) {
+		// Arrange
+		input := []int{1, 2, 3}
+		expected := []string{"1a", "2a", "3a"}
+
+		// Act
+		result := MapMany(input,
+			func(i int) []string {
+				return []string{"a", "b"}
+			},
+			func(i int, s string) *string {
+				if s == "b" {
+					return nil
+				}
+				res := string(rune(i+'0')) + s
+				return &res
+			})
+
+		// Assert
+		if !reflect.DeepEqual(result, expected) {
+			t.Errorf("Expected %v, got %v", expected, result)
+		}
+	})
+
+	t.Run("empty input array", func(t *testing.T) {
+		// Arrange
+		var input []int
+
+		// Act
+		result := MapMany(input,
+			func(i int) []string {
+				return []string{"a", "b"}
+			},
+			func(i int, s string) *string {
+				res := string(rune(i+'0')) + s
+				return &res
+			})
+
+		// Assert
+		if len(result) != 0 {
+			t.Errorf("Expected empty result, got %v", result)
+		}
+	})
+}
+
+func TestMapManyD(t *testing.T) {
+	t.Run("map dictionary to flattened array", func(t *testing.T) {
+		// Arrange
+		input := map[string]int{
+			"a": 1,
+			"b": 2,
+		}
+
+		// Act
+		result := MapManyD(input,
+			func(val int) []string {
+				return []string{"x", "y"}
+			},
+			func(s string) string {
+				return s + "z"
+			})
+
+		// Assert
+		// Since map iteration order is not guaranteed, we check that all expected elements are in the result
+		expectedElements := []string{"xz", "yz", "xz", "yz"}
+		if len(result) != len(expectedElements) {
+			t.Errorf("Expected result length %d, got %d", len(expectedElements), len(result))
+		}
+
+		resultMap := make(map[string]int)
+		for _, v := range result {
+			resultMap[v]++
+		}
+
+		if resultMap["xz"] != 2 || resultMap["yz"] != 2 {
+			t.Errorf("Expected result to contain 2 of each 'xz' and 'yz', got %v", resultMap)
+		}
+	})
+
+	t.Run("empty inner collection", func(t *testing.T) {
+		// Arrange
+		input := map[string]int{
+			"a": 1,
+			"b": 2,
+		}
+
+		// Act
+		result := MapManyD(input,
+			func(val int) []string {
+				return []string{}
+			},
+			func(s string) string {
+				return s + "z"
+			})
+
+		// Assert
+		if len(result) != 0 {
+			t.Errorf("Expected empty result, got %v", result)
+		}
+	})
+
+	t.Run("empty input map", func(t *testing.T) {
+		// Arrange
+		input := map[string]int{}
+
+		// Act
+		result := MapManyD(input,
+			func(val int) []string {
+				return []string{"x", "y"}
+			},
+			func(s string) string {
+				return s + "z"
+			})
+
+		// Assert
+		if len(result) != 0 {
+			t.Errorf("Expected empty result, got %v", result)
+		}
+	})
+}

pkg/array/sort.go

@@ -0,0 +1,72 @@
+package array
+
+import "sort"
+
+type Numbers interface {
+	int | int8 | int16 | int32 | int64 | float32 | float64
+}
+
+// BubbleSort
+// Deprecated; use sort package
+func BubbleSort[T any, N Numbers](arr []T, selector func(val T) N) {
+	n := len(arr)
+
+	for i := 0; i < n-1; i++ {
+		for j := 0; j < n-i-1; j++ {
+			c := selector(arr[j])
+			n := selector(arr[j+1])
+
+			if c > n {
+				// swap arr[j] and arr[j+1]
+				arr[j], arr[j+1] = arr[j+1], arr[j]
+			}
+		}
+	}
+}
+
+// BubbleSortDesc
+// Deprecated; use sort package
+func BubbleSortDesc[T any](arr []T, selector func(val T) float64) {
+	n := len(arr)
+
+	for i := 0; i < n-1; i++ {
+		for j := 0; j < n-i-1; j++ {
+			c := selector(arr[j])
+			n := selector(arr[j+1])
+
+			if c < n { // Change comparison operator to less than
+				// swap arr[j] and arr[j+1]
+				arr[j], arr[j+1] = arr[j+1], arr[j]
+			}
+		}
+	}
+}
+
+func FindDifference[T Numbers](primary, secondary []T) []T {
+	m := make(map[T]struct{})
+	for _, num := range secondary {
+		m[num] = struct{}{}
+	}
+
+	var diff []T
+	for _, num := range primary {
+		if _, found := m[num]; !found {
+			diff = append(diff, num)
+		}
+	}
+
+	return diff
+}
+
+func SortIntMap[T any](m map[int]T) []T {
+	result := make([]T, 0, len(m))
+	keys := make([]int, 0, len(m))
+	for k := range m {
+		keys = append(keys, k)
+	}
+	sort.Ints(keys)
+	for _, k := range keys {
+		result = append(result, m[k])
+	}
+	return result
+}

pkg/cache/cache.go

@@ -0,0 +1,129 @@
+package cache
+
+import (
+	"context"
+	"fmt"
+	"time"
+
+	"github.com/samber/lo"
+
+	"base/pkg/store"
+)
+
+type Cache[V any] interface {
+	WithCache(ctx context.Context, key string, fn func(context.Context) (V, error), ttl time.Duration) (V, error)
+	WithHashCache(ctx context.Context, set string, key []string, fn func(context.Context, []string) (map[string]V, error), ttl time.Duration) (map[string]V, error)
+	InvalidateKeys(ctx context.Context, keys ...string) error
+	InvalidatePattern(ctx context.Context, pattern string) error
+}
+
+type cache[V any] struct {
+	store.Store[V]
+}
+
+func New[V any](store store.Store[V]) Cache[V] {
+	return cache[V]{store}
+}
+
+func (c cache[V]) WithCache(ctx context.Context, key string, fn func(context.Context) (V, error), ttl time.Duration) (V, error) {
+	result, found, err := c.Get(ctx, key)
+	if err != nil {
+		return result, err
+	}
+
+	if found {
+		return result, nil
+	}
+
+	result, err = fn(ctx)
+	if err != nil {
+		return result, err
+	}
+
+	err = c.Set(ctx, key, result, ttl)
+	if err != nil {
+		return result, err
+	}
+
+	return result, nil
+}
+
+func (c cache[V]) WithHashCache(ctx context.Context, set string, keys []string, fn func(context.Context, []string) (map[string]V, error), ttl time.Duration) (map[string]V, error) {
+	fetchResult := make(map[string]V, len(keys))
+	var missKeys []string
+	var getError error
+
+	// step 1 try to get from redis and figure out missedKeys
+	// for when there are no keys ignore cache retrieve all from source
+	if len(keys) > 0 {
+		fetchResult, missKeys, getError = c.get(ctx, set, keys)
+		if getError != nil {
+			return nil, getError
+		}
+
+		// all target key founded
+		if len(missKeys) == 0 {
+			return fetchResult, nil
+		}
+	}
+
+	//fetch missedKeys from source
+	newResult, fnErr := fn(ctx, missKeys)
+	if fnErr != nil {
+		return nil, fnErr
+	}
+
+	// append new result to fetchResult
+	for key, val := range newResult {
+		fetchResult[key] = val
+	}
+
+	// set new founded keys
+	setErr := c.HMSet(ctx, set, newResult, ttl)
+	if setErr != nil {
+		return nil, setErr
+	}
+
+	return fetchResult, nil
+}
+
+func (c cache[V]) get(ctx context.Context, setKey string, keys []string) (map[string]V, []string, error) {
+	fetchResult, fetchErr := c.HMGet(ctx, setKey, keys...)
+	if fetchErr != nil {
+		return nil, nil, fetchErr
+	}
+
+	if len(fetchResult) == len(keys) {
+		return fetchResult, nil, nil
+	}
+
+	if len(fetchResult) == 0 {
+		// just for avoid nil panic in higher layer
+		fetchResult = make(map[string]V, len(keys))
+	}
+
+	// found miss key for fetch from source in higher level
+	missKeys := lo.Filter(keys, func(item string, index int) bool { return !lo.HasKey(fetchResult, item) })
+
+	return fetchResult, missKeys, nil
+}
+
+func (c cache[V]) InvalidateKeys(ctx context.Context, keys ...string) error {
+	if len(keys) == 0 {
+		return nil
+	}
+
+	if err := c.Store.DeleteMultiple(ctx, keys...); err != nil {
+		return fmt.Errorf("failed to invalidate keys: %w", err)
+	}
+
+	return nil
+}
+
+func (c cache[V]) InvalidatePattern(ctx context.Context, pattern string) error {
+	if err := c.Store.Delete(ctx, pattern); err != nil {
+		return fmt.Errorf("failed to invalidate pattern: %w", err)
+	}
+
+	return nil
+}

pkg/crypto/hash.go

@@ -0,0 +1,13 @@
+package crypto
+
+import (
+	"crypto/sha256"
+	"encoding/hex"
+	"fmt"
+)
+
+func Sha256(identifier string) string {
+	hash := sha256.Sum256([]byte(identifier))
+	hashStr := hex.EncodeToString(hash[:])
+	return fmt.Sprintf("%s", hashStr)
+}

pkg/email/interface.go

@@ -0,0 +1,39 @@
+package email
+
+import "context"
+
+type Email interface {
+	Send(ctx context.Context, params Request) (*Response, error)
+}
+
+type Response struct {
+	ID     string `json:"id"`
+	Status string `json:"status"`
+}
+
+type Request struct {
+	Html             string
+	RecipientAddress string
+	UserFullName     string
+	Subject          string
+	From             string
+	To               string
+	Template         TemplateData
+}
+
+type Template string
+
+const (
+	TemplateWelcome           = "welcome"
+	TemplatePasswordReset     = "password_reset"
+	TemplateEmailVerification = "email_verification"
+)
+
+func (e Template) String() string {
+	return string(e)
+}
+
+type TemplateData struct {
+	EmailTemplateName Template
+	Data              any
+}

pkg/enum/json.go

@@ -0,0 +1,22 @@
+package enum
+
+import (
+	"encoding/json"
+	"fmt"
+	"strings"
+)
+
+func MarshalEnum[T fmt.Stringer](val T) ([]byte, error) {
+	return json.Marshal(val.String())
+}
+
+func UnmarshalEnum[T fmt.Stringer](b []byte, enumValues []T) (T, error) {
+	var zero T
+	s := strings.Trim(string(b), `"`)
+	for _, val := range enumValues {
+		if val.String() == s {
+			return val, nil
+		}
+	}
+	return zero, fmt.Errorf("invalid value: %s", s)
+}

pkg/hash/service.go

@@ -0,0 +1,32 @@
+package hash
+
+import (
+	"context"
+	"crypto/sha256"
+	"encoding/hex"
+	"errors"
+
+	"golang.org/x/crypto/bcrypt"
+)
+
+var (
+	ErrHash = errors.New("wrong hash value")
+)
+
+func Hash(ctx context.Context, payload string) (string, error) {
+	bytes, err := bcrypt.GenerateFromPassword([]byte(payload), bcrypt.DefaultCost)
+	if err != nil {
+		return "", ErrHash
+	}
+	return string(bytes), nil
+}
+
+func CompareHash(ctx context.Context, hash string, payload string) bool {
+	err := bcrypt.CompareHashAndPassword([]byte(hash), []byte(payload))
+	return err == nil
+}
+
+func SHA256(ctx context.Context, payload string) string {
+	hash := sha256.Sum256([]byte(payload))
+	return hex.EncodeToString(hash[:])
+}

pkg/hashids/hashids.go

@@ -0,0 +1,45 @@
+package hashids
+
+import (
+	"fmt"
+	"os"
+
+	"github.com/speps/go-hashids"
+)
+
+var hids *hashids.HashID
+
+func GetHashids() *hashids.HashID {
+	if hids != nil {
+		return hids
+	}
+
+	hidsData := hashids.NewData()
+	hidsData.Alphabet = "abcdefghijklmnopqrstuvwxyz1234567890"
+	hidsData.Salt = os.Getenv("HASH_SALT")
+
+	hidsData.MinLength = 6
+	h, _ := hashids.NewWithData(hidsData)
+
+	return h
+}
+
+func GenerateCode(id int64) string {
+	numbers := make([]int, 1)
+	numbers[0] = int(id)
+	encoded, _ := GetHashids().Encode(numbers)
+	return encoded
+}
+
+func DecodeCode(code string) (int, error) {
+	decoded, err := GetHashids().DecodeWithError(code)
+
+	if err != nil {
+		return 0, err
+	}
+	if len(decoded) < 1 {
+		return 0, fmt.Errorf("invalid code")
+	}
+
+	return decoded[0], nil
+}

pkg/hashids/hashids_test.go

@@ -0,0 +1,33 @@
+package hashids
+
+import (
+	"fmt"
+	"os"
+	"testing"
+
+	"github.com/stretchr/testify/require"
+)
+
+func TestDecodeCode(t *testing.T) {
+	//code := "p5qggj"
+	//code := "37rx8m"
+	//code := "37r9dn"
+	code := "pz9vew"
+	err := os.Setenv("HASH_SALT", "qtyq68eqeqwy")
+
+	res, err := DecodeCode(code)
+	require.NoError(t, err)
+	fmt.Println(res)
+}
+
+func TestGenerateCode(t *testing.T) {
+	var productHub, dasht int64 = 1, 2
+
+	err := os.Setenv("HASH_SALT", "qtyq68eqeqwy")
+	require.NoError(t, err)
+
+	phub := GenerateCode(productHub)
+	fmt.Println(phub)
+	dashtID := GenerateCode(dasht)
+	fmt.Println(dashtID)
+}

pkg/health/const.go

@@ -0,0 +1,9 @@
+package health
+
+type Status string
+
+const (
+	StatusHealthy   Status = "healthy"
+	StatusUnhealthy Status = "unhealthy"
+	StatusDegraded  Status = "degraded"
+)

pkg/health/health.go

@@ -0,0 +1,82 @@
+package health
+
+import (
+	"context"
+	"sync"
+	"time"
+)
+
+type (
+	Checker func(ctx context.Context) HealthCheck
+
+	HealthCheck struct {
+		Name      string                 `json:"name"`
+		Status    Status                 `json:"status"`
+		Message   string                 `json:"message,omitempty"`
+		Timestamp time.Time              `json:"timestamp"`
+		Duration  time.Duration          `json:"duration"`
+		Details   map[string]interface{} `json:"details,omitempty"`
+	}
+
+	HealthResponse struct {
+		Status    Status                 `json:"status"`
+		Timestamp time.Time              `json:"timestamp"`
+		Version   string                 `json:"version"`
+		Checks    map[string]HealthCheck `json:"checks"`
+		Details   map[string]interface{} `json:"details,omitempty"`
+	}
+)
+
+func Health(ctx context.Context, version string, checkers ...Checker) HealthResponse {
+	start := time.Now()
+
+	results := make(map[string]HealthCheck, len(checkers))
+	wg := sync.WaitGroup{}
+	mu := sync.Mutex{}
+
+	wg.Add(len(checkers))
+	for _, checker := range checkers {
+		go func(c Checker) {
+			defer wg.Done()
+			check := c(ctx)
+			mu.Lock()
+			results[check.Name] = check
+			mu.Unlock()
+		}(checker)
+	}
+	wg.Wait()
+
+	// Determine overall status
+	overallStatus := determineOverallStatus(results)
+
+	return HealthResponse{
+		Status:    overallStatus,
+		Timestamp: time.Now(),
+		Version:   version,
+		Checks:    results,
+		Details: map[string]interface{}{
+			"uptime": time.Since(start).String(),
+		},
+	}
+}
+
+func determineOverallStatus(checks map[string]HealthCheck) Status {
+	var unhealthyCount, degradedCount int
+	for _, c := range checks {
+		switch c.Status {
+		case StatusUnhealthy:
+			unhealthyCount++
+		case StatusDegraded:
+			degradedCount++
+		}
+	}
+
+	switch {
+	case unhealthyCount > 0:
+		return StatusUnhealthy
+	case degradedCount > 0:
+		return StatusDegraded
+	default:
+		return StatusHealthy
+	}
+}

pkg/health/infra_checker.go

@@ -0,0 +1,113 @@
+package health
+
+import (
+	"context"
+	"github.com/redis/go-redis/v9"
+	"gorm.io/gorm"
+	rabbitmq "base/pkg/rabbit"
+	"time"
+)
+
+func DatabaseHealthChecker(db *gorm.DB) Checker {
+	return func(ctx context.Context) HealthCheck {
+		start := time.Now()
+		check := HealthCheck{
+			Name:      "database",
+			Timestamp: time.Now(),
+		}
+
+		// Perform health check
+		sqlDB, err := db.DB()
+		if err != nil {
+			check.Status = StatusUnhealthy
+			check.Message = "Failed to get database connection: " + err.Error()
+			check.Duration = time.Since(start)
+			return check
+		}
+
+		err = sqlDB.PingContext(ctx)
+		if err != nil {
+			check.Status = StatusUnhealthy
+			check.Message = "Database ping failed: " + err.Error()
+			check.Duration = time.Since(start)
+			return check
+		}
+
+		check.Status = StatusHealthy
+		check.Message = "Database connection is healthy"
+		check.Duration = time.Since(start)
+		check.Details = map[string]interface{}{
+			"connected": true,
+		}
+
+		return check
+	}
+}
+
+func RabbitMQHealthChecker(rabbitmq rabbitmq.Client) Checker {
+	return func(ctx context.Context) HealthCheck {
+		start := time.Now()
+		check := HealthCheck{
+			Name:      "rabbitmq",
+			Timestamp: time.Now(),
+		}
+
+		// Perform health check
+		err := rabbitmq.HealthCheck()
+		if err != nil {
+			check.Status = StatusUnhealthy
+			check.Message = "RabbitMQ health check failed: " + err.Error()
+			check.Duration = time.Since(start)
+			return check
+		}
+
+		check.Status = StatusHealthy
+		check.Message = "RabbitMQ connection is healthy"
+		check.Duration = time.Since(start)
+		check.Details = map[string]interface{}{
+			"connected": true,
+		}
+
+		return check
+	}
+}
+
+func RedisHealthChecker(redis *redis.Client) Checker {
+	return func(ctx context.Context) HealthCheck {
+		start := time.Now()
+		check := HealthCheck{
+			Name:      "redis",
+			Timestamp: time.Now(),
+		}
+
+		// Perform health check
+		ctx, cancel := context.WithTimeout(ctx, 5*time.Second)
+		defer cancel()
+
+		_, err := redis.Ping(ctx).Result()
+		if err != nil {
+			check.Status = StatusUnhealthy
+			check.Message = "Redis ping failed: " + err.Error()
+			check.Duration = time.Since(start)
+			return check
+		}
+
+		// Get Redis info
+		info, err := redis.Info(ctx, "server", "clients", "memory", "stats").Result()
+		if err != nil {
+			check.Status = StatusDegraded
+			check.Message = "Redis is responding but info command failed: " + err.Error()
+			check.Duration = time.Since(start)
+			return check
+		}
+
+		check.Status = StatusHealthy
+		check.Message = "Redis connection is healthy"
+		check.Duration = time.Since(start)
+		check.Details = map[string]interface{}{
+			"info": info,
+		}
+
+		return check
+	}
+}

pkg/helper/struct.go

@@ -0,0 +1,79 @@
+package helper
+
+import (
+	"encoding/json"
+	"fmt"
+	"reflect"
+	"strings"
+)
+
+func MapToStruct(source map[string]interface{}, target interface{}) error {
+	jsonBytes, err := json.Marshal(source)
+	if err != nil {
+		return err
+	}
+
+	err = json.Unmarshal(jsonBytes, target)
+	if err != nil {
+		return err
+	}
+
+	return nil
+}
+
+// StructToMap converts a struct to a map[string]interface{}
+// Uses json tag name as key when available, so keys match validation schema (e.g. "provider" not "Provider")
+// does not support nested structs
+func StructToMap(v any) map[string]interface{} {
+	result := make(map[string]interface{})
+	val := reflect.ValueOf(v)
+	typ := reflect.TypeOf(v)
+
+	if val.Kind() == reflect.Ptr {
+		val = val.Elem()
+		typ = typ.Elem()
+	}
+
+	for i := 0; i < val.NumField(); i++ {
+		field := typ.Field(i)
+		value := val.Field(i)
+
+		// Skip unexported fields
+		if !value.CanInterface() {
+			continue
+		}
+
+		key := field.Name
+		if tag := field.Tag.Get("json"); tag != "" {
+			// Use first part before comma (e.g. "provider,omitempty" -> "provider")
+			if name := strings.TrimSpace(strings.Split(tag, ",")[0]); name != "" && name != "-" {
+				key = name
+			}
+		}
+		fieldVal := value.Interface()
+		// If type implements String(), use it so validation gets string (e.g. oauth.Provider -> "mock")
+		// Use reflect to detect nil pointer - s != nil passes for interface holding (*T)(nil)
+		if s, ok := fieldVal.(fmt.Stringer); ok {
+			if isNilValue(value) {
+				result[key] = fieldVal // keep nil/zero for optional fields
+			} else {
+				result[key] = s.String()
+			}
+		} else {
+			result[key] = fieldVal
+		}
+	}
+
+	return result
+}
+
+// isNilValue returns true if v is nil (ptr, slice, map, chan, func, interface).
+// Used to avoid calling String() on nil receivers (e.g. *uuid.UUID).
+func isNilValue(v reflect.Value) bool {
+	switch v.Kind() {
+	case reflect.Ptr, reflect.Slice, reflect.Map, reflect.Chan, reflect.Func, reflect.Interface:
+		return v.IsNil()
+	default:
+		return false
+	}
+}

pkg/jwt/jwt.go

@@ -0,0 +1,37 @@
+package jwt
+
+import (
+	"context"
+	"time"
+)
+
+type AccessRefreshTokenPair struct {
+	AccessToken           string
+	AccessTokenExpiresAt  time.Time
+	RefreshToken          string
+	RefreshTokenExpiresAt time.Time
+}
+
+type TokenPayload struct {
+	Sub string
+	Aud []string
+	Iat time.Time
+	Exp time.Time
+	Iss string
+}
+
+type GenerateTokenInput struct {
+	Sub string
+	Aud string
+	Exp time.Time
+}
+
+type TokenData struct {
+	Sub string
+}
+
+type TokenService interface {
+	GenerateAccessRefreshTokenPair(ctx context.Context, tokenData *TokenData) (*AccessRefreshTokenPair, error)
+	VerifyToken(ctx context.Context, accessToken string) (*TokenPayload, error)
+	GenerateToken(ctx context.Context, input *GenerateTokenInput) (string, error)
+}

pkg/jwt/provider.go

@@ -0,0 +1,22 @@
+package jwt
+
+import (
+	"time"
+
+	"base/config"
+)
+
+// NewTokenService creates a new JWT TokenService from config
+func NewTokenService(cfg *config.AppConfig) TokenService {
+	secret := cfg.Server.JWTSecret
+	if secret == "" {
+		// Default secret if not configured (should be set in production)
+		secret = "default-secret-key-change-in-production"
+	}
+
+	// Default token expiration times
+	accessTokenExpiration := 24 * time.Hour
+	refreshTokenExpiration := 7 * 24 * time.Hour
+
+	return New(secret, accessTokenExpiration, refreshTokenExpiration)
+}

pkg/jwt/token_generator.go

@@ -0,0 +1,121 @@
+package jwt
+
+import (
+	"context"
+	"errors"
+	"time"
+
+	"github.com/lestrrat-go/jwx/v3/jwa"
+	"github.com/lestrrat-go/jwx/v3/jwt"
+)
+
+var (
+	ErrTokenVerificationFailed = errors.New("token verification failed")
+)
+
+type tokenService struct {
+	secretKey              []byte
+	accessTokenExpiration  time.Duration
+	refreshTokenExpiration time.Duration
+}
+
+func New(secret string, ate, rfe time.Duration) TokenService {
+	secretKey := []byte(secret)
+	return &tokenService{
+		secretKey:              secretKey,
+		accessTokenExpiration:  ate,
+		refreshTokenExpiration: rfe,
+	}
+}
+
+func (ts tokenService) GenerateAccessRefreshTokenPair(
+	ctx context.Context,
+	tokenData *TokenData,
+) (*AccessRefreshTokenPair, error) {
+	accessTokenExp := time.Now().Add(ts.accessTokenExpiration)
+	generateAccessJwt, err := ts.generateJwt(accessTokenExp, tokenData.Sub, "alinme-web")
+	if err != nil {
+		return nil, err
+	}
+
+	refreshTokenExp := time.Now().Add(ts.refreshTokenExpiration)
+	generateRefreshJwt, err := ts.generateJwt(refreshTokenExp, tokenData.Sub, "alinme-web")
+	if err != nil {
+		return nil, err
+	}
+
+	return &AccessRefreshTokenPair{
+		AccessToken:           generateAccessJwt,
+		AccessTokenExpiresAt:  accessTokenExp,
+		RefreshToken:          generateRefreshJwt,
+		RefreshTokenExpiresAt: refreshTokenExp,
+	}, nil
+}
+
+func (ts tokenService) generateJwt(exp time.Time, sub string, aud string) (string, error) {
+	t, err := jwt.NewBuilder().
+		Subject(sub).
+		IssuedAt(time.Now()).
+		Issuer("alinme-server").
+		Audience([]string{aud}).
+		Expiration(exp).
+		Build()
+
+	if err != nil {
+		return "", err
+	}
+	signed, err := jwt.Sign(t, jwt.WithKey(jwa.HS256(), ts.secretKey))
+	if err != nil {
+		return "", err
+	}
+	return string(signed), nil
+}
+
+func (ts tokenService) VerifyToken(ctx context.Context, accessToken string) (*TokenPayload, error) {
+	parsed, err := jwt.Parse([]byte(accessToken), jwt.WithKey(jwa.HS256(), ts.secretKey))
+	if err != nil {
+		return nil, ErrTokenVerificationFailed
+	}
+
+	sub, ok := parsed.Subject()
+	if !ok {
+		return nil, ErrTokenVerificationFailed
+	}
+
+	aud, ok := parsed.Audience()
+	if !ok {
+		return nil, ErrTokenVerificationFailed
+	}
+
+	iat, ok := parsed.IssuedAt()
+	if !ok {
+		return nil, ErrTokenVerificationFailed
+	}
+
+	exp, ok := parsed.Expiration()
+	if !ok {
+		return nil, ErrTokenVerificationFailed
+	}
+
+	iss, ok := parsed.Issuer()
+	if !ok {
+		return nil, ErrTokenVerificationFailed
+	}
+
+	return &TokenPayload{
+		Sub: sub,
+		Aud: aud,
+		Iat: iat,
+		Exp: exp,
+		Iss: iss,
+	}, nil
+}
+
+func (ts tokenService) GenerateToken(ctx context.Context, input *GenerateTokenInput) (string, error) {
+	generateJwt, err := ts.generateJwt(time.Now().Add(time.Minute*5), input.Sub, input.Aud)
+	if err != nil {
+		return "", err
+	}
+
+	return generateJwt, nil
+}

pkg/locker/errors.go

@@ -0,0 +1,21 @@
+package locker
+
+import "fmt"
+
+type LockErr struct {
+	id         string
+	maxRetries uint32
+	err        error
+}
+
+func NewLockError(id string, maxRetries uint32, acquireErr error) LockErr {
+	if acquireErr != nil {
+		return LockErr{id: id, maxRetries: maxRetries, err: acquireErr}
+	}
+
+	return LockErr{id, maxRetries, fmt.Errorf("failed to acquire lock after %d retries", maxRetries)}
+}
+
+func (l LockErr) Error() string {
+	return l.err.Error()
+}

pkg/locker/interface.go

@@ -0,0 +1,12 @@
+package locker
+
+import (
+	"context"
+	"time"
+)
+
+type Locker interface {
+	Lock(ctx context.Context, id string, ttl time.Duration) (bool, error)
+	Unlock(ctx context.Context, id string) error
+	WithLock(ctx context.Context, lockKey string, lockTime time.Duration, fn func(context.Context) error) error
+}

pkg/locker/locker.go

@@ -0,0 +1,98 @@
+package locker
+
+import (
+	"context"
+	"fmt"
+	"time"
+
+	"github.com/rs/zerolog"
+
+	"github.com/redis/go-redis/v9"
+)
+
+type locker struct {
+	client *redis.Client
+	logger zerolog.Logger
+}
+
+func NewLocker(client *redis.Client, logger zerolog.Logger) Locker {
+	return &locker{
+		client: client,
+		logger: logger,
+	}
+}
+
+func (l locker) Lock(ctx context.Context, id string, ttl time.Duration) (bool, error) {
+	status := l.client.SetNX(ctx, id, "locked", ttl)
+	if err := status.Err(); err != nil {
+		return false, err
+	}
+
+	// Return whether the lock was acquired
+	return status.Val(), nil
+}
+
+func (l locker) Unlock(ctx context.Context, id string) error {
+	// Delete the lock by its ID
+	_, err := l.client.Del(ctx, id).Result()
+	return err
+}
+
+// WithLock acquires a lock for a specific vendor, executes the provided function,
+// and ensures that the lock is released afterward. If any error occurs, it returns the
+// error, preserving the context of the lock operation.
+func (l locker) WithLock(
+	ctx context.Context,
+	lockKey string,
+	lockTime time.Duration,
+	fn func(context.Context) error,
+) error {
+	lg := l.logger.With().
+		Str("method", "WithLock").
+		Str("key", lockKey).
+		Logger()
+
+	maxRetries := 5
+	retryDelay := 10 * time.Millisecond //TODO: Replace with proper logging
+
+	var locked bool
+	var acquireErr error
+
+	for attempt := 0; attempt <= maxRetries; attempt++ {
+		locked, acquireErr = l.Lock(ctx, lockKey, lockTime)
+
+		if locked {
+			lg.Info().Msg("LockAcquired")
+			break
+		}
+
+		if attempt == maxRetries {
+			break
+		}
+
+		select {
+		case <-ctx.Done():
+			return ctx.Err()
+		case <-time.After(retryDelay):
+			retryDelay *= 2 // Exponential backoff
+		}
+	}
+
+	if !locked || acquireErr != nil {
+		lg.Error().Err(acquireErr).Msg("LockErr")
+		return NewLockError(lockKey, uint32(maxRetries), acquireErr)
+	}
+
+	fnErr := fn(ctx)
+	if fnErr != nil {
+		return fmt.Errorf("failed to execute function for %s due to error %v", lockKey, fnErr)
+	}
+
+	if unlockErr := l.Unlock(ctx, lockKey); unlockErr != nil {
+		return fmt.Errorf("failed to unlock lock for %s: %v", lockKey, unlockErr)
+	}
+
+	lg.Info().Msg("Unlocked")
+
+	return nil
+}

pkg/metrics/metrics.go

@@ -0,0 +1,283 @@
+package metrics
+
+import (
+	"fmt"
+	"regexp"
+	"runtime"
+	"strconv"
+	"strings"
+	"sync"
+	"time"
+
+	"github.com/prometheus/client_golang/prometheus"
+	"github.com/prometheus/client_golang/prometheus/promauto"
+)
+
+// Metrics holds all metrics for the base service
+type Metrics struct {
+	// HTTP metrics
+	HTTPRequest *prometheus.HistogramVec
+
+	// Database metrics
+	DatabaseQuery *prometheus.HistogramVec
+
+	// RabbitMQ metrics
+	RabbitMQMessages *prometheus.HistogramVec
+
+	// Business metrics
+	BusinessOperations *prometheus.HistogramVec
+
+	// Cache metrics
+	Cache *prometheus.HistogramVec
+
+	// External service metrics
+	ExternalServiceCall *prometheus.HistogramVec
+
+	// Configuration
+	namespace   string
+	subsystem   string
+	serviceName string
+}
+
+var (
+	metricsInstance *Metrics
+	metricsOnce     = &sync.Once{}
+	startTime       = time.Now()
+)
+
+// GetMetrics returns a singleton instance of Metrics
+func GetMetrics(namespace, subsystem, serviceName string) *Metrics {
+	metricsOnce.Do(func() {
+		metricsInstance = newMetrics(namespace, subsystem, serviceName)
+	})
+	return metricsInstance
+}
+
+// newMetrics creates a new instance of Metrics
+func newMetrics(namespace, subsystem, serviceName string) *Metrics {
+	return &Metrics{
+		namespace:   namespace,
+		subsystem:   subsystem,
+		serviceName: serviceName,
+
+		HTTPRequest: promauto.NewHistogramVec(
+			prometheus.HistogramOpts{
+				Namespace:   namespace,
+				Subsystem:   subsystem,
+				Name:        "http_request_duration_seconds",
+				Help:        "HTTP request duration in seconds",
+				Buckets:     prometheus.DefBuckets,
+				ConstLabels: prometheus.Labels{"service": serviceName},
+			},
+			[]string{"method", "endpoint", "status_code"},
+		),
+
+		DatabaseQuery: promauto.NewHistogramVec(
+			prometheus.HistogramOpts{
+				Namespace:   namespace,
+				Subsystem:   subsystem,
+				Name:        "database_query_duration_seconds",
+				Help:        "Database query duration in seconds",
+				Buckets:     prometheus.DefBuckets,
+				ConstLabels: prometheus.Labels{"service": serviceName},
+			},
+			[]string{"operation", "table", "error"},
+		),
+
+		// RabbitMQ metrics
+		RabbitMQMessages: promauto.NewHistogramVec(
+			prometheus.HistogramOpts{
+				Namespace:   namespace,
+				Subsystem:   subsystem,
+				Name:        "rabbitmq_messages_duration_seconds",
+				Help:        "Duration of RabbitMQ message operations (publish/consume) in seconds",
+				Buckets:     prometheus.DefBuckets,
+				ConstLabels: prometheus.Labels{"service": serviceName},
+			},
+			[]string{"exchange", "routing_key", "action", "error"},
+		),
+
+		// Business metrics
+		BusinessOperations: promauto.NewHistogramVec(
+			prometheus.HistogramOpts{
+				Namespace:   namespace,
+				Subsystem:   subsystem,
+				Name:        "business_operations_duration_seconds",
+				Help:        "Duration of business operations in seconds",
+				Buckets:     prometheus.DefBuckets,
+				ConstLabels: prometheus.Labels{"service": serviceName},
+			},
+			[]string{"operation_type", "error"},
+		),
+
+		// Cache metrics
+		Cache: promauto.NewHistogramVec(
+			prometheus.HistogramOpts{
+				Namespace:   namespace,
+				Subsystem:   subsystem,
+				Name:        "cache_operations_duration_seconds",
+				Help:        "Duration of store operations in seconds",
+				Buckets:     prometheus.DefBuckets,
+				ConstLabels: prometheus.Labels{"service": serviceName},
+			},
+			[]string{"cache_type", "key_pattern", "action", "hit", "error"},
+		),
+
+		ExternalServiceCall: promauto.NewHistogramVec(
+			prometheus.HistogramOpts{
+				Namespace:   namespace,
+				Subsystem:   subsystem,
+				Name:        "external_service_duration_seconds",
+				Help:        "External service call duration in seconds",
+				Buckets:     prometheus.DefBuckets,
+				ConstLabels: prometheus.Labels{"service": serviceName},
+			},
+			[]string{"service_name", "endpoint", "error"},
+		),
+	}
+}
+
+// GetNamespace returns the metrics namespace
+func (m *Metrics) GetNamespace() string {
+	return m.namespace
+}
+
+// GetSubsystem returns the metrics subsystem
+func (m *Metrics) GetSubsystem() string {
+	return m.subsystem
+}
+
+// GetServiceName returns the service name
+func (m *Metrics) GetServiceName() string {
+	return m.serviceName
+}
+
+// GetFullMetricName returns the full metric name with namespace and subsystem
+func (m *Metrics) GetFullMetricName(metricName string) string {
+	return fmt.Sprintf("%s_%s_%s", m.namespace, m.subsystem, metricName)
+}
+
+// RecordHTTPRequest HTTP Metrics Functions
+func (m *Metrics) RecordHTTPRequest(method, endpoint, statusCode string, duration time.Duration) {
+	m.HTTPRequest.WithLabelValues(method, endpoint, statusCode).Observe(duration.Seconds())
+}
+
+// NormalizePath normalizes HTTP paths by replacing numeric IDs and parameters with placeholders
+// This prevents metric cardinality explosion while maintaining meaningful endpoint grouping
+func (m *Metrics) NormalizePath(path string) string {
+	// Replace numeric IDs with :id placeholder
+	path = regexp.MustCompile(`/\d+`).ReplaceAllString(path, "/:id")
+
+	// Replace UUIDs with :uuid placeholder
+	path = regexp.MustCompile(`/[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}`).ReplaceAllString(path, "/:uuid")
+
+	// Replace other common parameter patterns
+	path = regexp.MustCompile(`/[a-zA-Z0-9]{20,}`).ReplaceAllString(path, "/:hash") // Long hashes
+	path = regexp.MustCompile(`/\d{10,}`).ReplaceAllString(path, "/:long_id")       // Very long numbers
+	return path
+}
+
+// NormalizeExternalServiceEndpoint normalizes external service endpoint names
+// Use this when you have dynamic endpoint names that could cause cardinality issues
+func (m *Metrics) NormalizeExternalServiceEndpoint(endpoint string) string {
+	// Replace numeric IDs with :id placeholder
+	endpoint = regexp.MustCompile(`\d+`).ReplaceAllString(endpoint, ":id")
+
+	// Replace UUIDs with :uuid placeholder
+	endpoint = regexp.MustCompile(`[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}`).ReplaceAllString(endpoint, ":uuid")
+
+	// Replace other common parameter patterns
+	endpoint = regexp.MustCompile(`[a-zA-Z0-9]{20,}`).ReplaceAllString(endpoint, ":hash") // Long hashes
+	endpoint = regexp.MustCompile(`\d{10,}`).ReplaceAllString(endpoint, ":long_id")       // Very long numbers
+
+	return endpoint
+}
+
+// RecordDatabaseQuery Database Metrics Functions
+func (m *Metrics) RecordDatabaseQuery(operation, table string, duration time.Duration, err error) {
+	m.DatabaseQuery.WithLabelValues(operation, table, m.classifyError(err)).Observe(duration.Seconds())
+}
+
+// RecordRabbitMQMessage RabbitMQ Metrics Functions
+func (m *Metrics) RecordRabbitMQMessage(exchange, routingKey, action string, duration time.Duration, err error) {
+	m.RabbitMQMessages.WithLabelValues(exchange, routingKey, action, m.classifyError(err)).Observe(duration.Seconds())
+}
+
+// RecordBusinessOperation Business Metrics Functions
+func (m *Metrics) RecordBusinessOperation(operationType string, err error, duration time.Duration) {
+	m.BusinessOperations.WithLabelValues(operationType, m.classifyError(err)).Observe(duration.Seconds())
+}
+
+// RecordCacheHit Cache Metrics Functions
+func (m *Metrics) RecordCacheHit(cacheType, keyPattern, action string, hit bool, err error, duration time.Duration) {
+	m.Cache.WithLabelValues(cacheType, keyPattern, action, strconv.FormatBool(hit), m.classifyError(err)).Observe(duration.Seconds())
+}
+
+// RecordExternalServiceCall External Service Metrics Functions
+func (m *Metrics) RecordExternalServiceCall(serviceName, endpoint string, err error, duration time.Duration) {
+	m.ExternalServiceCall.WithLabelValues(serviceName, endpoint, m.classifyError(err)).Observe(duration.Seconds())
+}
+
+// Utility Functions
+func (m *Metrics) classifyError(err error) string {
+	if err == nil {
+		return "none"
+	}
+
+	errStr := err.Error()
+	switch {
+	case strings.Contains(errStr, "connection"):
+		return "connection_error"
+	case strings.Contains(errStr, "connection lost"):
+		return "connection_lost"
+	case strings.Contains(errStr, "connection reset by peer"):
+		return "connection_reset_by_peer"
+	case strings.Contains(errStr, "timeout"):
+		return "timeout_error"
+	case strings.Contains(strings.ToLower(errStr), "deadlock"):
+		return "deadlock_error"
+	case strings.Contains(errStr, "not found") || strings.Contains(errStr, "NotFound"):
+		return "not_found_error"
+	case strings.Contains(errStr, "Duplicate"):
+		return "duplicate_error"
+	case strings.Contains(errStr, "permission"):
+		return "permission_error"
+	case strings.Contains(errStr, "validation"):
+		return "validation_error"
+	case strings.Contains(errStr, "failed to publish") || strings.Contains(errStr, "publish error"):
+		return "publish_error"
+	case strings.Contains(errStr, "failed to marshal"):
+		return "marshal_error"
+	case strings.Contains(errStr, "failed to save"):
+		return "save_error"
+	case strings.Contains(errStr, "too many open files"):
+		return "too_many_open_files"
+	case strings.Contains(errStr, "no such file or directory"):
+		return "no_such_file"
+	case strings.Contains(errStr, "failed to parse CSV"):
+		return "parse_csv_error"
+	case strings.Contains(errStr, "Internal Server Error"):
+		return "internal_server_error"
+	default:
+		return "unknown_error"
+	}
+}
+
+// RecordCacheMetrics records comprehensive store metrics
+func (m *Metrics) RecordCacheMetrics(cacheType, keyPattern, action string, hit bool, err error, duration time.Duration) {
+	m.RecordCacheHit(cacheType, keyPattern, action, hit, err, duration)
+}
+
+// RecordDatabaseOperation records comprehensive database operation metrics
+func (m *Metrics) RecordDatabaseOperation(operation, table string, duration time.Duration, err error) {
+	m.RecordDatabaseQuery(operation, table, duration, err)
+}
+
+// GetMetricsSummary returns a summary of current metrics
+func (m *Metrics) GetMetricsSummary() map[string]interface{} {
+	return map[string]interface{}{
+		"uptime_seconds": time.Since(startTime).Seconds(),
+		"goroutines":     runtime.NumGoroutine(),
+		"start_time":     startTime.Format(time.RFC3339),
+	}
+}

pkg/rabbit/client.go

@@ -0,0 +1,227 @@
+package rabbitmq
+
+import (
+	"fmt"
+	"sync"
+
+	amqp "github.com/rabbitmq/amqp091-go"
+	"github.com/rs/zerolog"
+
+	"base/pkg/metrics"
+)
+
+type client struct {
+	connectionManager ConnectionManager
+	publisher         Publisher
+	consumers         []Consumer
+	consumersMutex    sync.RWMutex
+	config            *Config
+	logger            zerolog.Logger
+}
+
+func NewClient(config *Config, logger zerolog.Logger, metric *metrics.Metrics) (Client, error) {
+	if config == nil {
+		config = DefaultConfig()
+	}
+
+	config.ApplyDefaults()
+	if err := config.Validate(); err != nil {
+		return nil, fmt.Errorf("invalid configuration: %w", err)
+	}
+
+	connMgr, err := NewConnectionManager(config, logger)
+	if err != nil {
+		return nil, fmt.Errorf("failed to create connection manager: %w", err)
+	}
+
+	c := &client{
+		connectionManager: connMgr,
+		publisher:         NewPublisher(connMgr, config, logger, metric),
+		consumers:         make([]Consumer, 0),
+		config:            config,
+		logger:            logger,
+	}
+
+	return c, nil
+}
+
+func (c *client) Publisher() Publisher {
+	return c.publisher
+}
+
+func (c *client) RegisterConsumer(handler MessageHandler, opts *ConsumerOptions) Consumer {
+	newConsumer := NewConsumer(c.connectionManager, handler, opts, c.logger)
+
+	c.consumersMutex.Lock()
+	c.consumers = append(c.consumers, newConsumer)
+	c.consumersMutex.Unlock()
+
+	c.logger.Info().Msgf("registered consumer with options: %v", opts)
+	return newConsumer
+}
+
+func (c *client) DeclareExchange(name string, opts ExchangeOptions) error {
+	ch, err := c.connectionManager.GetChannel()
+	if err != nil {
+		return NewConnectionError("get channel for exchange declaration", err)
+	}
+	defer c.connectionManager.ReturnChannel(ch)
+
+	err = ch.ExchangeDeclare(
+		name,
+		opts.Type,
+		opts.Durable,
+		opts.AutoDelete,
+		opts.Internal,
+		opts.NoWait,
+		opts.Args,
+	)
+	if err != nil {
+		return fmt.Errorf("failed to declare exchange '%s': %w", name, err)
+	}
+
+	c.logger.Info().Str("exchange", name).
+		Str("type", opts.Type).
+		Msg("Exchange declared successfully")
+
+	return nil
+}
+
+func (c *client) DeclareQueue(name string, opts QueueOptions) error {
+	ch, err := c.connectionManager.GetChannel()
+	if err != nil {
+		return NewConnectionError("get channel for queue declaration", err)
+	}
+	defer c.connectionManager.ReturnChannel(ch)
+
+	args := amqp.Table{}
+	if opts.Args != nil {
+		for k, v := range opts.Args {
+			args[k] = v
+		}
+	}
+
+	_, err = ch.QueueDeclare(
+		name,
+		opts.Durable,
+		opts.AutoDelete,
+		opts.Exclusive,
+		opts.NoWait,
+		args,
+	)
+	if err != nil {
+		return fmt.Errorf("failed to declare queue '%s': %w", name, err)
+	}
+
+	c.logger.Info().Msgf("Queue declared successfully: %s", name)
+	return nil
+}
+
+func (c *client) BindQueue(queue, exchange, routingKey string) error {
+	ch, err := c.connectionManager.GetChannel()
+	if err != nil {
+		return NewConnectionError("get channel for queue binding", err)
+	}
+	defer c.connectionManager.ReturnChannel(ch)
+
+	err = ch.QueueBind(
+		queue,
+		routingKey,
+		exchange,
+		false,
+		nil,
+	)
+	if err != nil {
+		return fmt.Errorf("failed to bind queue '%s' to exchange '%s' with routing key '%s': %w", queue, exchange, routingKey, err)
+	}
+
+	c.logger.Info().Msgf("Queue binded successfully: %s", queue)
+	return nil
+}
+
+func (c *client) DeleteQueue(name string) error {
+	ch, err := c.connectionManager.GetChannel()
+	if err != nil {
+		return NewConnectionError("get channel for queue deletion", err)
+	}
+	defer c.connectionManager.ReturnChannel(ch)
+
+	_, err = ch.QueueDelete(
+		name,
+		false, // ifUnused
+		false, // ifEmpty
+		false, // noWait
+	)
+	if err != nil {
+		return fmt.Errorf("failed to delete queue '%s': %w", name, err)
+	}
+
+	c.logger.Info().Msgf("Queue deleted successfully: %s", name)
+	return nil
+}
+
+func (c *client) DeleteExchange(name string) error {
+	ch, err := c.connectionManager.GetChannel()
+	if err != nil {
+		return NewConnectionError("get channel for exchange deletion", err)
+	}
+	defer c.connectionManager.ReturnChannel(ch)
+
+	err = ch.ExchangeDelete(
+		name,
+		false, // ifUnused
+		false, // noWait
+	)
+	if err != nil {
+		return fmt.Errorf("failed to delete exchange '%s': %w", name, err)
+	}
+
+	c.logger.Info().Msgf("Exchange deleted successfully: %s", name)
+	return nil
+}
+
+func (c *client) HealthCheck() error {
+	if !c.connectionManager.IsConnected() {
+		return ErrConnectionLost
+	}
+
+	// Try to get a channel and perform a basic operation
+	ch, err := c.connectionManager.GetChannel()
+	if err != nil {
+		return NewConnectionError("health check channel creation", err)
+	}
+	defer c.connectionManager.ReturnChannel(ch)
+
+	return nil
+}
+
+func (c *client) Close() error {
+	c.logger.Info().Msg("Closing RabbitMQ client...")
+
+	var closeErrors []error
+
+	if err := c.publisher.Close(); err != nil {
+		closeErrors = append(closeErrors, fmt.Errorf("publisher close error: %w", err))
+	}
+
+	// Close all additional consumers
+	c.consumersMutex.Lock()
+	for i, consumer := range c.consumers {
+		if err := consumer.Close(); err != nil {
+			closeErrors = append(closeErrors, fmt.Errorf("consumer %d close error: %w", i, err))
+		}
+	}
+	c.consumers = nil // Clear the slice
+	c.consumersMutex.Unlock()
+
+	if err := c.connectionManager.Close(); err != nil {
+		closeErrors = append(closeErrors, fmt.Errorf("connection manager close error: %w", err))
+	}
+
+	if len(closeErrors) > 0 {
+		return fmt.Errorf("errors during close: %v", closeErrors)
+	}
+
+	c.logger.Info().Msg("RabbitMQ client closed successfully")
+	return nil
+}

pkg/rabbit/config.go

@@ -0,0 +1,225 @@
+package rabbitmq
+
+import (
+	"fmt"
+	"net/url"
+	"time"
+)
+
+type Config struct {
+	// Connection settings
+	URL      string `json:"url"`
+	Host     string `json:"host"`
+	Port     int    `json:"port"`
+	Username string `json:"username"`
+	Password string `json:"password"`
+	VHost    string `json:"vhost"`
+	UseTLS   bool   `json:"use_tls"`
+
+	// Connection pool settings
+	MaxConnections    int           `json:"max_connections"`
+	MaxChannels       int           `json:"max_channels"`
+	ConnectionTimeout time.Duration `json:"connection_timeout"`
+	HeartbeatInterval time.Duration `json:"heartbeat_interval"`
+
+	// Reconnection settings
+	ReconnectDelay      time.Duration `json:"reconnect_delay"`
+	MaxReconnectDelay   time.Duration `json:"max_reconnect_delay"`
+	ReconnectAttempts   int           `json:"reconnect_attempts"`
+	EnableAutoReconnect bool          `json:"enable_auto_reconnect"`
+
+	// Publisher settings
+	PublisherConfig PublisherOptions `json:"publisher_config"`
+
+	// Health check settings
+	HealthCheckInterval time.Duration `json:"health_check_interval"`
+}
+
+func DefaultConfig() *Config {
+	return &Config{
+		Host:                "localhost",
+		Port:                5672,
+		Username:            "guest",
+		Password:            "guest",
+		VHost:               "/",
+		UseTLS:              false,
+		MaxConnections:      10,
+		MaxChannels:         100,
+		ConnectionTimeout:   30 * time.Second,
+		HeartbeatInterval:   60 * time.Second,
+		ReconnectDelay:      5 * time.Second,
+		MaxReconnectDelay:   5 * time.Minute,
+		ReconnectAttempts:   10,
+		EnableAutoReconnect: true,
+		PublisherConfig: PublisherOptions{
+			ConfirmMode:    true,
+			Mandatory:      false,
+			Immediate:      false,
+			RetryAttempts:  3,
+			RetryDelay:     1 * time.Second,
+			ConfirmTimeout: 10 * time.Second,
+		},
+		HealthCheckInterval: 30 * time.Second,
+	}
+}
+
+func (c *Config) BuildConnectionString() string {
+	if c.URL != "" {
+		return c.URL
+	}
+
+	scheme := "amqp"
+	if c.UseTLS {
+		scheme = "amqps"
+	}
+
+	// Build URL
+	u := &url.URL{
+		Scheme: scheme,
+		Host:   fmt.Sprintf("%s:%d", c.Host, c.Port),
+		Path:   c.VHost,
+	}
+
+	if c.Username != "" && c.Password != "" {
+		u.User = url.UserPassword(c.Username, c.Password)
+	}
+
+	return u.String()
+}
+
+func (c *Config) Validate() error {
+	if c.URL == "" {
+		if c.Host == "" {
+			return NewConfigurationError("host", c.Host, "host cannot be empty when URL is not provided")
+		}
+		if c.Port <= 0 || c.Port > 65535 {
+			return NewConfigurationError("port", c.Port, "port must be between 1 and 65535")
+		}
+	} else {
+		if _, err := url.Parse(c.URL); err != nil {
+			return NewConfigurationError("url", c.URL, fmt.Sprintf("invalid URL format: %v", err))
+		}
+	}
+
+	if c.MaxConnections <= 0 {
+		return NewConfigurationError("max_connections", c.MaxConnections, "max_connections must be greater than 0")
+	}
+
+	if c.MaxChannels <= 0 {
+		return NewConfigurationError("max_channels", c.MaxChannels, "max_channels must be greater than 0")
+	}
+
+	if c.ConnectionTimeout <= 0 {
+		return NewConfigurationError("connection_timeout", c.ConnectionTimeout, "connection_timeout must be greater than 0")
+	}
+
+	if c.HeartbeatInterval < 0 {
+		return NewConfigurationError("heartbeat_interval", c.HeartbeatInterval, "heartbeat_interval cannot be negative")
+	}
+
+	if c.ReconnectDelay <= 0 {
+		return NewConfigurationError("reconnect_delay", c.ReconnectDelay, "reconnect_delay must be greater than 0")
+	}
+
+	if c.MaxReconnectDelay < c.ReconnectDelay {
+		return NewConfigurationError("max_reconnect_delay", c.MaxReconnectDelay, "max_reconnect_delay must be greater than or equal to reconnect_delay")
+	}
+
+	if c.ReconnectAttempts < 0 {
+		return NewConfigurationError("reconnect_attempts", c.ReconnectAttempts, "reconnect_attempts cannot be negative")
+	}
+
+	if c.HealthCheckInterval < 0 {
+		return NewConfigurationError("health_check_interval", c.HealthCheckInterval, "health_check_interval cannot be negative")
+	}
+
+	return nil
+}
+
+func (c *Config) validatePublisherConfig() error {
+	if c.PublisherConfig.RetryAttempts < 0 {
+		return NewConfigurationError("publisher.retry_attempts", c.PublisherConfig.RetryAttempts, "retry_attempts cannot be negative")
+	}
+
+	if c.PublisherConfig.RetryDelay < 0 {
+		return NewConfigurationError("publisher.retry_delay", c.PublisherConfig.RetryDelay, "retry_delay cannot be negative")
+	}
+
+	if c.PublisherConfig.ConfirmTimeout <= 0 {
+		return NewConfigurationError("publisher.confirm_timeout", c.PublisherConfig.ConfirmTimeout, "confirm_timeout must be greater than 0")
+	}
+
+	return nil
+}
+
+func (c *Config) ApplyDefaults() {
+	defaults := DefaultConfig()
+
+	if c.Host == "" && c.URL == "" {
+		c.Host = defaults.Host
+	}
+	if c.Port == 0 {
+		c.Port = defaults.Port
+	}
+	if c.Username == "" {
+		c.Username = defaults.Username
+	}
+	if c.Password == "" {
+		c.Password = defaults.Password
+	}
+	if c.VHost == "" {
+		c.VHost = defaults.VHost
+	}
+	if c.MaxConnections == 0 {
+		c.MaxConnections = defaults.MaxConnections
+	}
+	if c.MaxChannels == 0 {
+		c.MaxChannels = defaults.MaxChannels
+	}
+	if c.ConnectionTimeout == 0 {
+		c.ConnectionTimeout = defaults.ConnectionTimeout
+	}
+	if c.HeartbeatInterval == 0 {
+		c.HeartbeatInterval = defaults.HeartbeatInterval
+	}
+	if c.ReconnectDelay == 0 {
+		c.ReconnectDelay = defaults.ReconnectDelay
+	}
+	if c.MaxReconnectDelay == 0 {
+		c.MaxReconnectDelay = defaults.MaxReconnectDelay
+	}
+	if c.ReconnectAttempts == 0 {
+		c.ReconnectAttempts = defaults.ReconnectAttempts
+	}
+
+	if c.HealthCheckInterval == 0 {
+		c.HealthCheckInterval = defaults.HealthCheckInterval
+	}
+
+	// Apply publisher defaults
+	if c.PublisherConfig.RetryAttempts == 0 {
+		c.PublisherConfig.RetryAttempts = defaults.PublisherConfig.RetryAttempts
+	}
+	if c.PublisherConfig.RetryDelay == 0 {
+		c.PublisherConfig.RetryDelay = defaults.PublisherConfig.RetryDelay
+	}
+	if c.PublisherConfig.ConfirmTimeout == 0 {
+		c.PublisherConfig.ConfirmTimeout = defaults.PublisherConfig.ConfirmTimeout
+	}
+
+}
+
+func (c *Config) Clone() *Config {
+	clone := *c
+
+	// Deep copy publisher config
+	clone.PublisherConfig = c.PublisherConfig
+	if c.PublisherConfig.Args != nil {
+		clone.PublisherConfig.Args = make(map[string]interface{})
+		for k, v := range c.PublisherConfig.Args {
+			clone.PublisherConfig.Args[k] = v
+		}
+	}
+
+	return &clone
+}

pkg/rabbit/connection.go

@@ -0,0 +1,312 @@
+package rabbitmq
+
+import (
+	"context"
+	"fmt"
+	"sync"
+	"sync/atomic"
+	"time"
+
+	amqp "github.com/rabbitmq/amqp091-go"
+	"github.com/rs/zerolog"
+)
+
+type connectionManager struct {
+	config            *Config
+	connection        *amqp.Connection
+	channels          []*amqp.Channel
+	connectionMutex   sync.RWMutex
+	channelMutex      sync.RWMutex
+	channelPool       chan *amqp.Channel
+	isConnected       int32 // atomic
+	isReconnecting    int32 // atomic
+	shutdownCh        chan struct{}
+	connectionLossCh  chan *amqp.Error
+	logger            zerolog.Logger
+	reconnectAttempts int
+	lastReconnectTime time.Time
+	wg                sync.WaitGroup
+	ctx               context.Context
+	cancel            context.CancelFunc
+}
+
+func NewConnectionManager(config *Config, logger zerolog.Logger) (ConnectionManager, error) {
+	if err := config.Validate(); err != nil {
+		return nil, fmt.Errorf("invalid configuration: %w", err)
+	}
+
+	ctx, cancel := context.WithCancel(context.Background())
+
+	cm := &connectionManager{
+		config:           config,
+		shutdownCh:       make(chan struct{}),
+		connectionLossCh: make(chan *amqp.Error, 100),
+		logger:           logger,
+		channelPool:      make(chan *amqp.Channel, config.MaxChannels),
+		ctx:              ctx,
+		cancel:           cancel,
+	}
+
+	if err := cm.connect(); err != nil {
+		cancel()
+		return nil, NewConnectionError("initial connection", err)
+	}
+
+	if config.EnableAutoReconnect {
+		cm.wg.Add(1)
+		go cm.reconnectLoop()
+	}
+
+	if config.HealthCheckInterval > 0 {
+		cm.wg.Add(1)
+		go cm.healthCheckLoop()
+	}
+
+	return cm, nil
+}
+
+func (cm *connectionManager) GetConnection() (*amqp.Connection, error) {
+	cm.connectionMutex.RLock()
+	defer cm.connectionMutex.RUnlock()
+
+	if cm.connection == nil || cm.connection.IsClosed() {
+		return nil, ErrConnectionLost
+	}
+
+	return cm.connection, nil
+}
+
+func (cm *connectionManager) GetChannel() (*amqp.Channel, error) {
+	// Try to get from pool first
+	select {
+	case ch := <-cm.channelPool:
+		if ch != nil && !ch.IsClosed() {
+			return ch, nil
+		}
+	default:
+	}
+
+	// Create new channel
+	conn, err := cm.GetConnection()
+	if err != nil {
+		return nil, err
+	}
+
+	ch, err := conn.Channel()
+	if err != nil {
+		return nil, NewConnectionError("create channel", err)
+	}
+
+	cm.channelMutex.Lock()
+	cm.channels = append(cm.channels, ch)
+	cm.channelMutex.Unlock()
+
+	return ch, nil
+}
+
+func (cm *connectionManager) ReturnChannel(ch *amqp.Channel) {
+	if ch == nil || ch.IsClosed() {
+		return
+	}
+
+	select {
+	case cm.channelPool <- ch:
+	default:
+		ch.Close()
+	}
+}
+
+func (cm *connectionManager) Close() error {
+	cm.logger.Info().Msg("Closing RabbitMQ connection manager...")
+
+	close(cm.shutdownCh)
+	cm.cancel()
+
+	cm.wg.Wait()
+
+	// Close all channels
+	cm.channelMutex.Lock()
+	for _, ch := range cm.channels {
+		if ch != nil && !ch.IsClosed() {
+			ch.Close()
+		}
+	}
+	cm.channels = nil
+	cm.channelMutex.Unlock()
+
+	// Close channel pool
+	close(cm.channelPool)
+	for ch := range cm.channelPool {
+		if ch != nil && !ch.IsClosed() {
+			ch.Close()
+		}
+	}
+
+	// Close connection
+	cm.connectionMutex.Lock()
+	defer cm.connectionMutex.Unlock()
+
+	if cm.connection != nil && !cm.connection.IsClosed() {
+		return cm.connection.Close()
+	}
+
+	return nil
+}
+
+func (cm *connectionManager) IsConnected() bool {
+	return atomic.LoadInt32(&cm.isConnected) == 1
+}
+
+func (cm *connectionManager) NotifyConnectionLoss() <-chan *amqp.Error {
+	return cm.connectionLossCh
+}
+
+func (cm *connectionManager) connect() error {
+	cm.logger.Info().Msg("Connecting to RabbitMQ")
+
+	config := amqp.Config{
+		Heartbeat: cm.config.HeartbeatInterval,
+		Locale:    "en_US",
+	}
+
+	if cm.config.ConnectionTimeout > 0 {
+		config.Dial = amqp.DefaultDial(cm.config.ConnectionTimeout)
+	}
+
+	conn, err := amqp.DialConfig(cm.config.BuildConnectionString(), config)
+	if err != nil {
+		return fmt.Errorf("failed to connect: %w", err)
+	}
+
+	cm.connectionMutex.Lock()
+	cm.connection = conn
+	cm.connectionMutex.Unlock()
+
+	atomic.StoreInt32(&cm.isConnected, 1)
+	cm.reconnectAttempts = 0
+
+	// Setup connection close notification
+	go cm.handleConnectionClose(conn.NotifyClose(make(chan *amqp.Error)))
+
+	cm.logger.Info().Msg("Connected to RabbitMQ")
+	return nil
+}
+
+func (cm *connectionManager) handleConnectionClose(closeCh <-chan *amqp.Error) {
+	select {
+	case err := <-closeCh:
+		if err != nil {
+			cm.logger.Error().Err(err).Msg("Connection lost")
+			atomic.StoreInt32(&cm.isConnected, 0)
+
+			select {
+			case cm.connectionLossCh <- err:
+			default:
+				cm.logger.Error().Err(err).Msg("Connection channel full, dropping notification")
+			}
+
+			// Close all channels
+			cm.channelMutex.Lock()
+			for _, ch := range cm.channels {
+				if ch != nil && !ch.IsClosed() {
+					ch.Close()
+				}
+			}
+			cm.channels = nil
+			cm.channelMutex.Unlock()
+		}
+	case <-cm.shutdownCh:
+		return
+	}
+}
+
+func (cm *connectionManager) reconnectLoop() {
+	defer cm.wg.Done()
+
+	ticker := time.NewTicker(cm.config.ReconnectDelay)
+	defer ticker.Stop()
+
+	for {
+		select {
+		case <-ticker.C:
+			if !cm.IsConnected() && atomic.CompareAndSwapInt32(&cm.isReconnecting, 0, 1) {
+				cm.attemptReconnect()
+				atomic.StoreInt32(&cm.isReconnecting, 0)
+			}
+		case <-cm.shutdownCh:
+			return
+		}
+	}
+}
+
+func (cm *connectionManager) attemptReconnect() {
+	if cm.config.ReconnectAttempts > 0 && cm.reconnectAttempts >= cm.config.ReconnectAttempts {
+		cm.logger.Error().Msgf("Max reconnect attempts reached: %d", cm.config.ReconnectAttempts)
+		return
+	}
+
+	delay := cm.config.ReconnectDelay
+	if cm.reconnectAttempts > 0 {
+		backoff := time.Duration(cm.reconnectAttempts) * cm.config.ReconnectDelay
+		if backoff > cm.config.MaxReconnectDelay {
+			delay = cm.config.MaxReconnectDelay
+		} else {
+			delay = backoff
+		}
+	}
+
+	if time.Since(cm.lastReconnectTime) < delay {
+		time.Sleep(delay - time.Since(cm.lastReconnectTime))
+	}
+
+	cm.reconnectAttempts++
+	cm.lastReconnectTime = time.Now()
+
+	cm.logger.Info().Msgf("Attempting to reconnect (attempt %d, delay %s)", cm.reconnectAttempts, delay)
+
+	if err := cm.connect(); err != nil {
+		//cm.logger.WithError(err).WithField("attempt", cm.reconnectAttempts).Error("Reconnection failed")
+		cm.logger.Error().Err(err).Msgf("Reconnection failed (attempt %d)", cm.reconnectAttempts)
+	} else {
+		cm.logger.Info().Msgf("Reconnected successfully (attempt %d)", cm.reconnectAttempts)
+	}
+}
+
+func (cm *connectionManager) healthCheckLoop() {
+	defer cm.wg.Done()
+
+	ticker := time.NewTicker(cm.config.HealthCheckInterval)
+	defer ticker.Stop()
+
+	for {
+		select {
+		case <-ticker.C:
+			if err := cm.healthCheck(); err != nil {
+				cm.logger.Error().Err(err).Msg("Health check failed")
+				atomic.StoreInt32(&cm.isConnected, 0)
+			}
+		case <-cm.shutdownCh:
+			return
+		}
+	}
+}
+
+func (cm *connectionManager) healthCheck() error {
+	conn, err := cm.GetConnection()
+	if err != nil {
+		return err
+	}
+
+	if conn.IsClosed() {
+		return ErrConnectionLost
+	}
+
+	// Try to create and close a channel to verify connection health
+	ch, err := conn.Channel()
+	if err != nil {
+		return NewConnectionError("health check channel creation", err)
+	}
+	defer ch.Close()
+
+	return nil
+}

pkg/rabbit/consumer.go

@@ -0,0 +1,200 @@
+package rabbitmq
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"sync"
+	"time"
+
+	amqp "github.com/rabbitmq/amqp091-go"
+	"github.com/rs/zerolog"
+)
+
+type consumer struct {
+	connectionManager ConnectionManager
+	handler           MessageHandler
+	opts              *ConsumerOptions
+	logger            zerolog.Logger
+	isConsuming       bool
+	consumeMutex      sync.RWMutex
+	shutdownCh        chan struct{}
+	wg                sync.WaitGroup
+}
+
+func NewConsumer(connectionManager ConnectionManager, handler MessageHandler, opts *ConsumerOptions, logger zerolog.Logger) Consumer {
+	return &consumer{
+		connectionManager: connectionManager,
+		handler:           handler,
+		opts:              opts,
+		logger:            logger,
+		shutdownCh:        make(chan struct{}),
+	}
+}
+
+func (c *consumer) Consume(ctx context.Context) error {
+	c.consumeMutex.Lock()
+	if c.isConsuming {
+		c.consumeMutex.Unlock()
+		return fmt.Errorf("consumer is already consuming")
+	}
+	c.isConsuming = true
+	c.consumeMutex.Unlock()
+
+	defer func() {
+		c.consumeMutex.Lock()
+		c.isConsuming = false
+		c.consumeMutex.Unlock()
+	}()
+
+	c.logger.Info().Msgf("starting consumer for queue %s", c.opts.Queue)
+
+	for {
+		select {
+		case <-ctx.Done():
+			c.logger.Info().Bool("withErr", ctx.Err() != nil).Msgf("stopping consumer for queue %s", c.opts.Queue)
+			return ctx.Err()
+		case <-c.shutdownCh:
+			c.logger.Info().Msgf("stopping consumer for queue %s with shoutdown", c.opts.Queue)
+			return nil
+		default:
+			if err := c.consumeLoop(ctx, c.opts.Queue, c.handler); err != nil {
+				c.logger.Error().
+					Err(err).
+					Str("errType", fmt.Sprintf("%T", err)).
+					Msgf("error consuming message for queue %s: %s", c.opts.Queue, err)
+
+				// If it's a connection error, wait and retry
+				var connectionError *ConnectionError
+				if errors.As(err, &connectionError) {
+					select {
+					case <-ctx.Done():
+						return ctx.Err()
+					case <-time.After(c.opts.ReconnectWait):
+						continue
+					}
+				}
+
+				// if consume error occurred (including delivery channel closed), wait and retry
+				var consumeErr *ConsumeError
+				if errors.As(err, &consumeErr) {
+					c.logger.Warn().Err(errors.Unwrap(consumeErr)).Msg("consume error, will retry")
+					select {
+					case <-ctx.Done():
+						return ctx.Err()
+					case <-time.After(c.opts.ReconnectWait):
+						continue
+					}
+				}
+
+				continue
+			}
+		}
+	}
+}
+
+func (c *consumer) consumeLoop(ctx context.Context, queue string, handler MessageHandler) error {
+	ch, err := c.connectionManager.GetChannel()
+	if err != nil {
+		return NewConsumeError(queue, err)
+	}
+
+	if c.opts.PrefetchCount > 0 {
+		err = ch.Qos(
+			c.opts.PrefetchCount,
+			c.opts.PrefetchSize,
+			false,
+		)
+		if err != nil {
+			ch.Close()
+			return NewConnectionError("set channel QoS", err)
+		}
+	}
+
+	defer c.connectionManager.ReturnChannel(ch)
+
+	// Start consuming
+	deliveries, err := ch.Consume(
+		queue,
+		c.opts.ConsumerTag,
+		c.opts.AutoAck,
+		c.opts.Exclusive,
+		c.opts.NoLocal,
+		c.opts.NoWait,
+		c.opts.Args,
+	)
+	if err != nil {
+		return NewConsumeError(queue, fmt.Errorf("failed to start consuming: %w", err))
+	}
+
+	c.logger.Info().Msgf("starting consumer for queue %s", queue)
+
+	for {
+		select {
+		case <-ctx.Done():
+			return ctx.Err()
+		case <-c.shutdownCh:
+			return nil
+		case delivery, ok := <-deliveries:
+			if !ok {
+				c.logger.Warn().Msgf("delivery channel closed for queue %s, will retry", queue)
+				return NewConsumeError(queue, fmt.Errorf("delivery channel closed"))
+			}
+
+			c.wg.Add(1)
+			go func(d amqp.Delivery) {
+				defer c.wg.Done()
+				c.handleDelivery(ctx, d, handler)
+			}(delivery)
+		}
+	}
+}
+
+func (c *consumer) handleDelivery(ctx context.Context, delivery amqp.Delivery, handler MessageHandler) {
+	msg := c.deliveryToMessage(delivery)
+
+	handler(ctx, msg)
+}
+
+func (c *consumer) deliveryToMessage(delivery amqp.Delivery) *Message {
+	headers := make(map[string]interface{})
+	for k, v := range delivery.Headers {
+		headers[k] = v
+	}
+
+	msg := &Message{
+		ID:            delivery.MessageId,
+		Body:          delivery.Body,
+		ContentType:   delivery.ContentType,
+		Headers:       headers,
+		Timestamp:     delivery.Timestamp,
+		Expiration:    delivery.Expiration,
+		Priority:      delivery.Priority,
+		DeliveryMode:  delivery.DeliveryMode,
+		ReplyTo:       delivery.ReplyTo,
+		CorrelationID: delivery.CorrelationId,
+		delivery:      &delivery, // Attach delivery for acknowledgment
+		acknowledged:  false,
+	}
+
+	// Set ID from headers if not available in MessageId
+	if msg.ID == "" {
+		if id, ok := headers["x-message-id"].(string); ok {
+			msg.ID = id
+		}
+	}
+
+	return msg
+}
+
+func (c *consumer) Close() error {
+	c.logger.Info().Msg("closing consumer")
+
+	// Signal shutdown
+	close(c.shutdownCh)
+
+	// Wait for all message handlers to complete
+	c.wg.Wait()
+
+	return nil
+}

pkg/rabbit/errors.go

@@ -0,0 +1,105 @@
+package rabbitmq
+
+import (
+	"errors"
+	"fmt"
+)
+
+var (
+	ErrConnectionLost      = errors.New("rabbitmq connection lost")
+	ErrConnectionFailed    = errors.New("failed to connect to rabbitmq")
+	ErrChannelClosed       = errors.New("rabbitmq channel closed")
+	ErrInvalidConfig       = errors.New("invalid configuration")
+	ErrPublishFailed       = errors.New("failed to publish message")
+	ErrConsumeFailed       = errors.New("failed to consume message")
+	ErrConfirmationTimeout = errors.New("message confirmation timeout")
+	ErrSerializationFailed = errors.New("message serialization failed")
+	ErrMaxRetriesExceeded  = errors.New("maximum retry attempts exceeded")
+	ErrInvalidMessage      = errors.New("invalid message format")
+	ErrQueueNotExists      = errors.New("queue does not exist")
+	ErrExchangeNotExists   = errors.New("exchange does not exist")
+)
+
+type ConnectionError struct {
+	Operation string
+	Err       error
+}
+
+func (e *ConnectionError) Error() string {
+	return fmt.Sprintf("connection error during %s: %v", e.Operation, e.Err)
+}
+
+type PublishError struct {
+	Exchange   string
+	RoutingKey string
+	Err        error
+}
+
+func (e *PublishError) Error() string {
+	return fmt.Sprintf("publish error to exchange '%s' with routing key '%s': %v", e.Exchange, e.RoutingKey, e.Err)
+}
+
+type ConsumeError struct {
+	Queue string
+	Err   error
+}
+
+func (e *ConsumeError) Error() string {
+	return fmt.Sprintf("consume error from queue '%s': %v", e.Queue, e.Err)
+}
+
+type ConfigurationError struct {
+	Field  string
+	Value  interface{}
+	Reason string
+}
+
+func (e *ConfigurationError) Error() string {
+	return fmt.Sprintf("configuration error: field '%s' with value '%v' - %s", e.Field, e.Value, e.Reason)
+}
+
+type RetryError struct {
+	Attempts int
+	LastErr  error
+}
+
+func (e *RetryError) Error() string {
+	return fmt.Sprintf("retry failed after %d attempts: %v", e.Attempts, e.LastErr)
+}
+
+func NewConnectionError(operation string, err error) *ConnectionError {
+	return &ConnectionError{
+		Operation: operation,
+		Err:       err,
+	}
+}
+
+func NewPublishError(exchange, routingKey string, err error) *PublishError {
+	return &PublishError{
+		Exchange:   exchange,
+		RoutingKey: routingKey,
+		Err:        err,
+	}
+}
+
+func NewConsumeError(queue string, err error) *ConsumeError {
+	return &ConsumeError{
+		Queue: queue,
+		Err:   err,
+	}
+}
+
+func NewConfigurationError(field string, value interface{}, reason string) *ConfigurationError {
+	return &ConfigurationError{
+		Field:  field,
+		Value:  value,
+		Reason: reason,
+	}
+}
+
+func NewRetryError(attempts int, lastErr error) *RetryError {
+	return &RetryError{
+		Attempts: attempts,
+		LastErr:  lastErr,
+	}
+}

pkg/rabbit/message.go

@@ -0,0 +1,150 @@
+package rabbitmq
+
+import (
+	"fmt"
+	"sync"
+	"time"
+
+	amqp "github.com/rabbitmq/amqp091-go"
+)
+
+type Message struct {
+	ID            string                 `json:"id"`
+	Body          []byte                 `json:"body"`
+	ContentType   string                 `json:"content_type"`
+	Headers       map[string]interface{} `json:"headers"`
+	Timestamp     time.Time              `json:"timestamp"`
+	Expiration    string                 `json:"expiration,omitempty"`
+	Priority      uint8                  `json:"priority,omitempty"`
+	DeliveryMode  uint8                  `json:"delivery_mode"`
+	ReplyTo       string                 `json:"reply_to,omitempty"`
+	CorrelationID string                 `json:"correlation_id,omitempty"`
+
+	// Internal fields for acknowledgment (not exported in JSON)
+	delivery     *amqp.Delivery `json:"-"`
+	acknowledged bool           `json:"-"`
+	ackMutex     sync.Mutex     `json:"-"`
+}
+
+func (m *Message) Ack() error {
+	m.ackMutex.Lock()
+	defer m.ackMutex.Unlock()
+
+	if m.delivery == nil {
+		return fmt.Errorf("message delivery is nil - cannot acknowledge")
+	}
+
+	if m.acknowledged {
+		return fmt.Errorf("message already acknowledged")
+	}
+
+	m.acknowledged = true
+	return m.delivery.Ack(false)
+}
+
+func (m *Message) AckMultiple() error {
+	m.ackMutex.Lock()
+	defer m.ackMutex.Unlock()
+
+	if m.delivery == nil {
+		return fmt.Errorf("message delivery is nil - cannot acknowledge")
+	}
+
+	if m.acknowledged {
+		return fmt.Errorf("message already acknowledged")
+	}
+
+	m.acknowledged = true
+	return m.delivery.Ack(true)
+}
+
+func (m *Message) Nack(requeue bool) error {
+	m.ackMutex.Lock()
+	defer m.ackMutex.Unlock()
+
+	if m.delivery == nil {
+		return fmt.Errorf("message delivery is nil - cannot nack")
+	}
+
+	if m.acknowledged {
+		return fmt.Errorf("message already acknowledged")
+	}
+
+	m.acknowledged = true
+	// Note: When requeue=false, message goes to DLQ and RabbitMQ automatically
+	// tracks retry count via x-death header. No need for custom IncrementRetryCount().
+	return m.delivery.Nack(false, requeue)
+}
+
+func (m *Message) NackMultiple(requeue bool) error {
+	m.ackMutex.Lock()
+	defer m.ackMutex.Unlock()
+
+	if m.delivery == nil {
+		return fmt.Errorf("message delivery is nil - cannot nack")
+	}
+
+	if m.acknowledged {
+		return fmt.Errorf("message already acknowledged")
+	}
+
+	m.acknowledged = true
+	return m.delivery.Nack(true, requeue)
+}
+
+func (m *Message) Reject(requeue bool) error {
+	m.ackMutex.Lock()
+	defer m.ackMutex.Unlock()
+
+	if m.delivery == nil {
+		return fmt.Errorf("message delivery is nil - cannot reject")
+	}
+
+	if m.acknowledged {
+		return fmt.Errorf("message already acknowledged")
+	}
+
+	m.acknowledged = true
+	return m.delivery.Reject(requeue)
+}
+
+func (m *Message) IsAcknowledged() bool {
+	m.ackMutex.Lock()
+	defer m.ackMutex.Unlock()
+	return m.acknowledged
+}
+
+func (m *Message) GetRetryCount() int64 {
+	if m.Headers == nil {
+		return 0
+	}
+
+	if retryCount, ok := m.Headers["x-retry-count"]; ok {
+		switch v := retryCount.(type) {
+		case int:
+			return int64(v)
+		case int64:
+			return v
+		case string:
+			// Try to parse string as integer
+			if count := parseInt(v); count >= 0 {
+				return count
+			}
+		}
+	}
+
+	xDeath, exists := m.Headers["x-death"].([]interface{})
+	if exists {
+		return xDeath[0].(amqp.Table)["count"].(int64)
+	}
+
+	return 0
+}
+func parseInt(s string) int64 {
+	var count int64
+	_, err := fmt.Sscanf(s, "%d", &count)
+	if err != nil {
+		return -1
+	}
+	return count
+}

pkg/rabbit/publisher.go

@@ -0,0 +1,223 @@
+package rabbitmq
+
+import (
+	"context"
+	"fmt"
+	"sync"
+	"time"
+
+	"github.com/google/uuid"
+	amqp "github.com/rabbitmq/amqp091-go"
+	"github.com/rs/zerolog"
+
+	"base/pkg/metrics"
+)
+
+type publisher struct {
+	connectionManager ConnectionManager
+	config            *Config
+	logger            zerolog.Logger
+	confirmChannels   map[uint64]chan amqp.Confirmation
+	confirmMutex      sync.RWMutex
+	nextConfirmID     uint64
+	confirmMux        sync.Mutex
+	metric            *metrics.Metrics
+}
+
+func NewPublisher(
+	connectionManager ConnectionManager,
+	config *Config,
+	logger zerolog.Logger,
+	metric *metrics.Metrics,
+) Publisher {
+	return &publisher{
+		connectionManager: connectionManager,
+		config:            config,
+		logger:            logger,
+		confirmChannels:   make(map[uint64]chan amqp.Confirmation),
+		metric:            metric,
+	}
+}
+
+func (p *publisher) Publish(ctx context.Context, exchange, routingKey string, msg *Message) error {
+	start := time.Now()
+	pubErr := p.publishWithRetry(ctx, exchange, routingKey, msg, false)
+	duration := time.Since(start)
+
+	p.metric.RecordRabbitMQMessage(exchange, routingKey, "publish", duration, pubErr)
+
+	return pubErr
+}
+
+func (p *publisher) publishWithRetry(ctx context.Context, exchange, routingKey string, msg *Message, withConfirmation bool) error {
+	var lastErr error
+
+	if msg == nil {
+		return ErrInvalidMessage
+	}
+
+	if msg.ID == "" {
+		msg.ID = uuid.New().String()
+	}
+
+	if msg.Timestamp.IsZero() {
+		msg.Timestamp = time.Now()
+	}
+
+	if msg.DeliveryMode == 0 {
+		msg.DeliveryMode = DeliveryModePersistent
+	}
+
+	maxAttempts := p.config.PublisherConfig.RetryAttempts + 1
+
+	for attempt := 0; attempt < maxAttempts; attempt++ {
+		if attempt > 0 {
+
+			select {
+			case <-ctx.Done():
+				return ctx.Err()
+			case <-time.After(p.config.PublisherConfig.RetryDelay):
+			}
+		}
+
+		err := p.doPublish(ctx, exchange, routingKey, msg, withConfirmation)
+		if err == nil {
+			return nil
+		}
+
+		lastErr = err
+
+		if !p.isRetryableError(err) {
+			break
+		}
+
+		p.logger.Warn().Str("exchange", exchange).
+			Str("routing_key", routingKey).
+			Str("message_id", msg.ID).
+			Int("attempt", attempt+1).
+			Int("max_attempts", maxAttempts).
+			Err(err).
+			Msg("Retrying message publish")
+	}
+
+	return NewRetryError(maxAttempts, lastErr)
+}
+
+func (p *publisher) doPublish(ctx context.Context, exchange, routingKey string, msg *Message, withConfirmation bool) error {
+	ch, err := p.connectionManager.GetChannel()
+	if err != nil {
+		return NewPublishError(exchange, routingKey, err)
+	}
+	defer p.connectionManager.ReturnChannel(ch)
+
+	// Convert message to AMQP publishing
+	publishing, err := p.messageToPublishing(msg)
+	if err != nil {
+		return NewPublishError(exchange, routingKey, fmt.Errorf("failed publish in convert message: %w", err))
+	}
+
+	// Publish the message
+	err = ch.PublishWithContext(
+		ctx,
+		exchange,
+		routingKey,
+		p.config.PublisherConfig.Mandatory,
+		p.config.PublisherConfig.Immediate,
+		*publishing,
+	)
+
+	if err != nil {
+		return NewPublishError(exchange, routingKey, fmt.Errorf("failed to publish: %w", err))
+	}
+
+	p.logger.Info().
+		Str("exchange", exchange).
+		Str("payload", string(msg.Body)).
+		Str("correlationID", msg.CorrelationID).
+		Str("routing_key", routingKey).Msg("MessagePublished")
+	return nil
+}
+
+func (p *publisher) messageToPublishing(msg *Message) (*amqp.Publishing, error) {
+	headers := make(amqp.Table)
+	for k, v := range msg.Headers {
+		headers[k] = v
+	}
+
+	// Add metadata headers
+	headers["x-message-id"] = msg.ID
+	headers["x-published-at"] = msg.Timestamp.Format(time.RFC3339)
+
+	publishing := &amqp.Publishing{
+		Headers:       headers,
+		ContentType:   msg.ContentType,
+		Body:          msg.Body,
+		DeliveryMode:  msg.DeliveryMode,
+		Priority:      msg.Priority,
+		Timestamp:     msg.Timestamp,
+		MessageId:     msg.ID,
+		ReplyTo:       msg.ReplyTo,
+		CorrelationId: msg.CorrelationID,
+	}
+
+	if msg.Expiration != "" {
+		publishing.Expiration = msg.Expiration
+	}
+
+	return publishing, nil
+}
+
+func (p *publisher) isRetryableError(err error) bool {
+	if err == nil {
+		return false
+	}
+
+	// Check for specific error types that should not be retried
+	switch err {
+	case ErrInvalidMessage:
+		return false
+	case ErrInvalidConfig:
+		return false
+	}
+
+	// Check for AMQP errors
+	if amqpErr, ok := err.(*amqp.Error); ok {
+		switch amqpErr.Code {
+		case amqp.NotFound: // 404 - Queue/Exchange not found
+			return false
+		case amqp.AccessRefused: // 403 - Access refused
+			return false
+		case amqp.InvalidPath: // 402 - Invalid path
+			return false
+		case amqp.ResourceLocked: // 405 - Resource locked
+			return false
+		case amqp.PreconditionFailed: // 406 - Precondition failed
+			return false
+		case amqp.NotImplemented: // 540 - Not implemented
+			return false
+		default:
+			return true
+		}
+	}
+
+	// Check for connection errors (these are usually retryable)
+	if _, ok := err.(*ConnectionError); ok {
+		return true
+	}
+
+	return true
+}
+
+func (p *publisher) Close() error {
+	p.logger.Info().Msg("Closing publisher")
+
+	// Close all confirmation channels
+	p.confirmMutex.Lock()
+	for _, ch := range p.confirmChannels {
+		close(ch)
+	}
+	p.confirmChannels = make(map[uint64]chan amqp.Confirmation)
+	p.confirmMutex.Unlock()
+
+	return nil
+}

pkg/rabbit/rabbitmq.go

@@ -0,0 +1,103 @@
+package rabbitmq
+
+import (
+	"context"
+	"time"
+
+	amqp "github.com/rabbitmq/amqp091-go"
+)
+
+const Version = "1.0.0"
+
+type Publisher interface {
+	Publish(ctx context.Context, exchange, routingKey string, msg *Message) error
+	Close() error
+}
+
+type Consumer interface {
+	Consume(ctx context.Context) error
+	Close() error
+}
+
+type MessageHandler func(ctx context.Context, msg *Message)
+
+type Client interface {
+	Publisher() Publisher
+	RegisterConsumer(handler MessageHandler, opts *ConsumerOptions) Consumer
+	DeclareQueue(name string, opts QueueOptions) error
+	DeclareExchange(name string, opts ExchangeOptions) error
+	BindQueue(queue, exchange, routingKey string) error
+	DeleteQueue(name string) error
+	DeleteExchange(name string) error
+	HealthCheck() error
+	Close() error
+}
+
+type ConnectionManager interface {
+	GetConnection() (*amqp.Connection, error)
+	GetChannel() (*amqp.Channel, error)
+	ReturnChannel(*amqp.Channel)
+	Close() error
+	IsConnected() bool
+	NotifyConnectionLoss() <-chan *amqp.Error
+}
+
+type QueueOptions struct {
+	Durable    bool
+	AutoDelete bool
+	Exclusive  bool
+	NoWait     bool
+	Args       amqp.Table
+}
+
+type ExchangeOptions struct {
+	Type       string
+	Durable    bool
+	AutoDelete bool
+	Internal   bool
+	NoWait     bool
+	Args       amqp.Table
+}
+
+type ConsumerOptions struct {
+	Queue         string
+	ConsumerTag   string
+	AutoAck       bool
+	Exclusive     bool
+	NoLocal       bool
+	NoWait        bool
+	PrefetchCount int
+	PrefetchSize  int
+	Args          amqp.Table
+	ReconnectWait time.Duration
+}
+
+type PublisherOptions struct {
+	ConfirmMode    bool
+	Mandatory      bool
+	Immediate      bool
+	RetryAttempts  int
+	RetryDelay     time.Duration
+	ConfirmTimeout time.Duration
+	Args           amqp.Table
+}
+
+const (
+	ExchangeTypeDirect  = "direct"
+	ExchangeTypeFanout  = "fanout"
+	ExchangeTypeTopic   = "topic"
+	ExchangeTypeHeaders = "headers"
+)
+
+const (
+	DeliveryModeTransient  = 1
+	DeliveryModePersistent = 2
+)
+
+const (
+	PriorityLowest  = 0
+	PriorityLow     = 64
+	PriorityNormal  = 128
+	PriorityHigh    = 192
+	PriorityHighest = 255
+)

pkg/reflectutil/structpopulate.go

@@ -0,0 +1,196 @@
+package reflectutil
+
+import (
+	"fmt"
+	"reflect"
+	"strings"
+)
+
+// ValueGetter wraps a map[string]any and implements ValueGetter
+type ValueGetter map[string]any
+
+// Get retrieves a value from the map by key
+func (m ValueGetter) Get(key string) (any, bool) {
+	v, ok := m[key]
+	return v, ok
+}
+
+// GetFloat64 retrieves a float64 value from the map by key
+func (m ValueGetter) GetFloat64(key string) (float64, bool) {
+	v, ok := m.Get(key)
+	if !ok {
+		return 0, false
+	}
+
+	switch val := v.(type) {
+	case float64:
+		return val, true
+	case float32:
+		return float64(val), true
+	case int:
+		return float64(val), true
+	case int64:
+		return float64(val), true
+	case int32:
+		return float64(val), true
+	default:
+		return 0, false
+	}
+}
+
+// GetInt retrieves an int value from the map by key
+func (m ValueGetter) GetInt(key string) (int, bool) {
+	v, ok := m.Get(key)
+	if !ok {
+		return 0, false
+	}
+
+	switch val := v.(type) {
+	case int:
+		return val, true
+	case int64:
+		return int(val), true
+	case int32:
+		return int(val), true
+	case float64:
+		return int(val), true
+	case float32:
+		return int(val), true
+	default:
+		return 0, false
+	}
+}
+
+// GetString retrieves a string value from the map by key
+func (m ValueGetter) GetString(key string) (string, bool) {
+	v, ok := m.Get(key)
+	if !ok {
+		return "", false
+	}
+
+	switch val := v.(type) {
+	case string:
+		return val, true
+	default:
+		return "", false
+	}
+}
+
+// GetJSONTagName extracts the JSON tag name from a struct field
+func GetJSONTagName(field reflect.StructField) string {
+	tag := field.Tag.Get("json")
+	if tag == "" || tag == "-" {
+		return ""
+	}
+	// Handle cases like `json:"name,omitempty"` - take only the first part
+	if idx := strings.Index(tag, ","); idx != -1 {
+		tag = tag[:idx]
+	}
+	return tag
+}
+
+// getFloat64FromAny converts an any value to float64
+func getFloat64FromAny(v any) (float64, bool) {
+	switch val := v.(type) {
+	case float64:
+		return val, true
+	case float32:
+		return float64(val), true
+	case int:
+		return float64(val), true
+	case int64:
+		return float64(val), true
+	case int32:
+		return float64(val), true
+	default:
+		return 0, false
+	}
+}
+
+// getIntFromAny converts an any value to int
+func getIntFromAny(v any) (int, bool) {
+	switch val := v.(type) {
+	case int:
+		return val, true
+	case int64:
+		return int(val), true
+	case int32:
+		return int(val), true
+	case float64:
+		return int(val), true
+	case float32:
+		return int(val), true
+	default:
+		return 0, false
+	}
+}
+
+// getStringFromAny converts an any value to string
+func getStringFromAny(v any) (string, bool) {
+	switch val := v.(type) {
+	case string:
+		return val, true
+	default:
+		return "", false
+	}
+}
+
+// PopulateStructFromMap populates a struct from a map[string]any using reflection
+// The target must be a pointer to a struct
+func PopulateStructFromMap(m map[string]any, target interface{}) error {
+	v := reflect.ValueOf(target)
+	if v.Kind() != reflect.Ptr || v.Elem().Kind() != reflect.Struct {
+		return fmt.Errorf("target must be a pointer to a struct")
+	}
+
+	v = v.Elem()
+	t := v.Type()
+
+	for i := 0; i < v.NumField(); i++ {
+		field := v.Field(i)
+		fieldType := t.Field(i)
+
+		if !field.CanSet() {
+			continue
+		}
+
+		jsonTag := GetJSONTagName(fieldType)
+		if jsonTag == "" {
+			continue
+		}
+
+		mapVal, ok := m[jsonTag]
+		if !ok {
+			return fmt.Errorf("%s not found in map", jsonTag)
+		}
+
+		fieldKind := field.Kind()
+		switch fieldKind {
+		case reflect.Float64:
+			val, ok := getFloat64FromAny(mapVal)
+			if !ok {
+				return fmt.Errorf("cannot convert %s to float64 for field %s", reflect.TypeOf(mapVal), jsonTag)
+			}
+			field.SetFloat(val)
+
+		case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+			val, ok := getIntFromAny(mapVal)
+			if !ok {
+				return fmt.Errorf("cannot convert %s to int for field %s", reflect.TypeOf(mapVal), jsonTag)
+			}
+			field.SetInt(int64(val))
+
+		case reflect.String:
+			val, ok := getStringFromAny(mapVal)
+			if !ok {
+				return fmt.Errorf("cannot convert %s to string for field %s", reflect.TypeOf(mapVal), jsonTag)
+			}
+			field.SetString(val)
+
+		default:
+			return fmt.Errorf("unsupported field type %s for field %s", fieldKind, jsonTag)
+		}
+	}
+
+	return nil
+}

pkg/store/postgres.go

@@ -0,0 +1,193 @@
+package store
+
+import (
+	"context"
+	"encoding/json"
+	"errors"
+	"strings"
+	"time"
+
+	"github.com/rs/zerolog"
+	"gorm.io/gorm"
+	"gorm.io/gorm/clause"
+
+	"base/internal/repository/postgres/cache"
+	"base/pkg/metrics"
+)
+
+// PostgresStore  implements Store interface using Redis
+type PostgresStore[V any] struct {
+	db            *gorm.DB
+	logger        zerolog.Logger
+	metrics       *metrics.Metrics
+	kvTableName   string
+	hashTableName string
+}
+
+func NewPostgresStore[V any](db *gorm.DB, logger zerolog.Logger, metrics *metrics.Metrics) Store[V] {
+	return &PostgresStore[V]{
+		db:            db,
+		logger:        logger,
+		metrics:       metrics,
+		kvTableName:   cache.KVModel{}.TableName(),
+		hashTableName: cache.HashModel{}.TableName(),
+	}
+}
+
+// Delete implements [Store].
+func (p *PostgresStore[V]) Delete(ctx context.Context, key string) error {
+	err := p.db.WithContext(ctx).
+		Table(p.kvTableName).
+		Where("key = ?", key).
+		Delete(&cache.KVModel{}).Error
+
+	if errors.Is(err, gorm.ErrRecordNotFound) {
+		p.logger.Error().Err(err).Str("key", key).Msg("key not found")
+		return nil
+	}
+	if err != nil {
+		p.logger.Error().Err(err).Str("key", key).Msg("failed to delete key")
+		return err
+	}
+
+	return err
+}
+
+// DeleteMultiple implements [Store].
+func (p *PostgresStore[V]) DeleteMultiple(ctx context.Context, keys ...string) error {
+	err := p.db.WithContext(ctx).
+		Table(p.kvTableName).
+		Where("key IN (?)", keys).
+		Delete(&cache.KVModel{}).Error
+
+	if errors.Is(err, gorm.ErrRecordNotFound) {
+		p.logger.Error().Err(err).Str("keys", strings.Join(keys, ", ")).Msg("keys not found")
+		return nil
+	}
+	if err != nil {
+		p.logger.Error().Err(err).Str("keys", strings.Join(keys, ", ")).Msg("failed to delete keys")
+		return err
+	}
+
+	return err
+}
+
+// DeletePattern implements [Store].
+func (p *PostgresStore[V]) DeletePattern(ctx context.Context, pattern string) error {
+	err := p.db.WithContext(ctx).
+		Table(p.kvTableName).
+		Where("key LIKE ?", pattern).
+		Delete(&cache.KVModel{}).Error
+
+	if errors.Is(err, gorm.ErrRecordNotFound) {
+		p.logger.Error().Err(err).Str("pattern", pattern).Msg("pattern not found")
+		return nil
+	}
+	if err != nil {
+		p.logger.Error().Err(err).Str("pattern", pattern).Msg("failed to delete pattern")
+		return err
+	}
+
+	return err
+}
+
+// Exists implements [Store].
+func (p *PostgresStore[V]) Exists(ctx context.Context, key string) (bool, error) {
+	var count int64
+	err := p.db.WithContext(ctx).Table(p.kvTableName).
+		Where("key = ? AND (expires_at IS NULL OR expires_at > ?)", key, time.Now()).
+		Count(&count).Error
+
+	if errors.Is(err, gorm.ErrRecordNotFound) {
+		p.logger.Error().Err(err).Str("key", key).Msg("key not found")
+		return false, nil
+	}
+	if err != nil {
+		p.logger.Error().Err(err).Str("key", key).Msg("failed to check if key exists")
+		return false, err
+	}
+
+	return count > 0, nil
+}
+
+// Get implements [Store].
+func (p *PostgresStore[V]) Get(ctx context.Context, key string) (V, bool, error) {
+	var row cache.KVModel
+	err := p.db.WithContext(ctx).Table(p.kvTableName).
+		Where("key = ? AND (expires_at IS NULL OR expires_at > ?)", key, time.Now()).
+		First(&row).Error
+
+	if errors.Is(err, gorm.ErrRecordNotFound) {
+		var zero V
+		return zero, false, nil
+	}
+	if err != nil {
+		var zero V
+		return zero, false, err
+	}
+
+	var val V
+	if err := json.Unmarshal(row.Value, &val); err != nil {
+		return val, false, err
+	}
+
+	return val, true, nil
+}
+
+// HGetAll implements [Store].
+func (p *PostgresStore[V]) HGetAll(ctx context.Context, key string) (map[string]V, error) {
+	panic("unimplemented")
+}
+
+// HMGet implements [Store].
+func (p *PostgresStore[V]) HMGet(ctx context.Context, key string, fields ...string) (map[string]V, error) {
+	panic("unimplemented")
+}
+
+// HMSet implements [Store].
+func (p *PostgresStore[V]) HMSet(ctx context.Context, key string, values map[string]V, expiration time.Duration) error {
+	panic("unimplemented")
+}
+
+// Set implements [Store].
+func (p *PostgresStore[V]) Set(ctx context.Context, key string, value V, expiration time.Duration) error {
+	data, _ := json.Marshal(value)
+
+	var expires *time.Time
+	if expiration > 0 {
+		t := time.Now().Add(expiration)
+		expires = &t
+	}
+
+	err := p.db.WithContext(ctx).
+		Table(p.kvTableName).
+		Clauses(clause.OnConflict{
+			UpdateAll: true,
+		}).
+		Create(&cache.KVModel{
+			Key:       key,
+			Value:     data,
+			ExpiresAt: expires,
+		}).Error
+
+	if errors.Is(err, gorm.ErrRecordNotFound) {
+		p.logger.Error().Err(err).Str("key", key).Msg("key not found")
+		return nil
+	}
+	if err != nil {
+		p.logger.Error().Err(err).Str("key", key).Msg("failed to set key")
+		return err
+	}
+
+	return err
+}
+
+// SetMultiple implements [Store].
+func (p *PostgresStore[V]) SetMultiple(ctx context.Context, items map[string]V, expiration time.Duration) error {
+	panic("unimplemented")
+}
+
+// SetNX implements [Store].
+func (p *PostgresStore[V]) SetNX(ctx context.Context, key string, value V, expiration time.Duration) (bool, error) {
+	panic("unimplemented")
+}

pkg/store/redis.go

@@ -0,0 +1,372 @@
+package store
+
+import (
+	"context"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"time"
+
+	"github.com/redis/go-redis/v9"
+	"github.com/rs/zerolog"
+
+	"base/pkg/metrics"
+)
+
+// RedisStore implements Store interface using Redis
+type RedisStore[V any] struct {
+	client  *redis.Client
+	logger  *zerolog.Logger
+	metrics *metrics.Metrics
+}
+
+// NewRedisStore creates a new Redis store instance
+func NewRedisStore[V any](client *redis.Client, logger *zerolog.Logger, metrics *metrics.Metrics) Store[V] {
+	return &RedisStore[V]{
+		client:  client,
+		logger:  logger,
+		metrics: metrics,
+	}
+}
+
+// Get retrieves a value from store by key
+func (c *RedisStore[V]) Get(ctx context.Context, key string) (V, bool, error) {
+	var zero V
+
+	keyPattern, err := extractKeyPattern(key)
+	if err != nil {
+		return zero, false, err
+	}
+
+	start := time.Now()
+	dest, exist, getErr := c.get(ctx, key)
+	duration := time.Since(start)
+
+	c.metrics.RecordCacheHit("redis", keyPattern, "get", exist, getErr, duration)
+	return dest, exist, err
+}
+
+func (c *RedisStore[V]) get(ctx context.Context, key string) (V, bool, error) {
+	var zero V
+
+	val, err := c.client.Get(ctx, key).Result()
+	if err != nil {
+		if errors.Is(err, redis.Nil) {
+			return zero, false, nil
+		}
+
+		return zero, false, fmt.Errorf("failed to get key %s: %w", key, err)
+	}
+
+	newDest := new(V)
+
+	// Try to unmarshal the value
+	if err = json.Unmarshal([]byte(val), newDest); err != nil {
+		return zero, false, fmt.Errorf("failed to unmarshal cached value for key %s: %w", key, err)
+	}
+
+	return *newDest, true, nil
+}
+
+// Set stores a value in store with expiration
+func (c *RedisStore[V]) Set(ctx context.Context, key string, value V, expiration time.Duration) error {
+	return c.set(ctx, key, value, expiration)
+}
+
+func (c *RedisStore[V]) set(ctx context.Context, key string, value interface{}, expiration time.Duration) error {
+	data, err := marshalValue(key, value)
+	if err != nil {
+		return err
+	}
+
+	err = c.client.Set(ctx, key, data, expiration).Err()
+
+	if err != nil {
+		return fmt.Errorf("failed to set key %s: %w", key, err)
+	}
+
+	return nil
+}
+
+// Delete removes a key from store
+func (c *RedisStore[V]) Delete(ctx context.Context, key string) error {
+	return c.client.Del(ctx, key).Err()
+}
+
+func (c *RedisStore[V]) delete(ctx context.Context, key string) error {
+	err := c.client.Del(ctx, key).Err()
+	if err != nil {
+		return fmt.Errorf("failed to delete key %s: %w", key, err)
+	}
+
+	return nil
+}
+
+// Exists checks if a key exists in store
+func (c *RedisStore[V]) Exists(ctx context.Context, key string) (bool, error) {
+	keyPattern, err := extractKeyPattern(key)
+	if err != nil {
+		return false, err
+	}
+
+	start := time.Now()
+
+	exists, err := c.exists(ctx, key)
+	duration := time.Since(start)
+
+	c.metrics.RecordCacheHit("redis", keyPattern, "exists", exists, err, duration)
+
+	return exists, err
+}
+
+func (c *RedisStore[V]) exists(ctx context.Context, key string) (bool, error) {
+	exists, err := c.client.Exists(ctx, key).Result()
+	if err != nil {
+		return false, fmt.Errorf("failed to check existence of key %s: %w", key, err)
+	}
+
+	result := exists > 0
+	return result, nil
+}
+
+// SetNX sets a value only if the key doesn't exist (atomic operation)
+func (c *RedisStore[V]) SetNX(ctx context.Context, key string, value V, expiration time.Duration) (bool, error) {
+	keyPattern, err := extractKeyPattern(key)
+	if err != nil {
+		return false, err
+	}
+
+	start := time.Now()
+
+	success, err := c.setNX(ctx, key, value, expiration)
+	duration := time.Since(start)
+
+	c.metrics.RecordCacheHit("redis", keyPattern, "setNx", success, err, duration)
+
+	return success, err
+}
+
+func (c *RedisStore[V]) setNX(ctx context.Context, key string, value V, expiration time.Duration) (bool, error) {
+	var data []byte
+	var err error
+
+	// Vry to marshal the value to JSON
+	if data, err = json.Marshal(value); err != nil {
+		return false, fmt.Errorf("failed to marshal value for key %s: %w", key, err)
+	}
+
+	success, err := c.client.SetNX(ctx, key, data, expiration).Result()
+	if err != nil {
+		return false, fmt.Errorf("failed to set key %s with NX: %w", key, err)
+	}
+
+	return success, nil
+}
+
+// HMGet retrieves multiple fields from a hash
+func (c *RedisStore[V]) HMGet(ctx context.Context, key string, keys ...string) (map[string]V, error) {
+	keyPattern, err := extractKeyPattern(key)
+	if err != nil {
+		return nil, err
+	}
+
+	start := time.Now()
+	result, getErr := c.hmGet(ctx, key, keys...)
+	duration := time.Since(start)
+
+	c.metrics.RecordCacheHit("redis", keyPattern, "hmget", len(result) > 0 && getErr == nil, getErr, duration)
+	return result, err
+}
+
+func (c *RedisStore[V]) hmGet(ctx context.Context, key string, fields ...string) (map[string]V, error) {
+	vals, err := c.client.HMGet(ctx, key, fields...).Result()
+	if err != nil {
+		return nil, fmt.Errorf("failed to hmget key %s: %w", key, err)
+	}
+
+	result := make(map[string]V, len(fields))
+	for i, field := range fields {
+		if vals[i] != nil {
+			serializedValue, serializeValueErr := serializeValue[V](vals[i])
+			if serializeValueErr != nil {
+				return nil, serializeValueErr
+			}
+
+			result[field] = serializedValue
+		}
+	}
+
+	return result, nil
+}
+
+// HGetAll retrieves multiple fields from a hash
+func (c *RedisStore[V]) HGetAll(ctx context.Context, key string) (map[string]V, error) {
+	keyPattern, err := extractKeyPattern(key)
+	if err != nil {
+		return nil, err
+	}
+
+	start := time.Now()
+
+	result, getErr := c.hGetAll(ctx, key)
+	duration := time.Since(start)
+
+	c.metrics.RecordCacheHit("redis", keyPattern, "hmget", len(result) > 0 && getErr == nil, getErr, duration)
+	return result, err
+}
+
+func (c *RedisStore[V]) hGetAll(ctx context.Context, key string) (map[string]V, error) {
+	vals, err := c.client.HGetAll(ctx, key).Result()
+	if err != nil {
+		return nil, fmt.Errorf("failed to hmget key %s: %w", key, err)
+	}
+
+	result := make(map[string]V)
+	for _, field := range vals {
+		serializedValue, serializeValueErr := serializeValue[V](field)
+		if serializeValueErr != nil {
+			return nil, serializeValueErr
+		}
+
+		result[field] = serializedValue
+
+	}
+
+	return result, nil
+}
+
+// HMSet sets multiple fields in a hash with expiration
+func (c *RedisStore[V]) HMSet(ctx context.Context, key string, values map[string]V, expiration time.Duration) error {
+	return c.hmSet(ctx, key, values, expiration)
+}
+
+func (c *RedisStore[V]) hmSet(ctx context.Context, key string, values map[string]V, expiration time.Duration) error {
+	if len(values) == 0 {
+		return nil
+	}
+
+	// Convert values to string format for Redis hash
+	hashValues := make(map[string]interface{}, len(values))
+	for field, value := range values {
+		serializedValue, err := json.Marshal(value)
+		if err != nil {
+			return err
+		}
+		hashValues[field] = serializedValue
+	}
+
+	// Set hash fields
+	err := c.client.HMSet(ctx, key, hashValues).Err()
+	if err != nil {
+		return fmt.Errorf("failed to hmset key %s: %w", key, err)
+	}
+
+	// Set expiration if specified
+	if expiration > 0 {
+		err = c.client.Expire(ctx, key, expiration).Err()
+		if err != nil {
+			return fmt.Errorf("failed to set expiration for key %s: %w", key, err)
+		}
+	}
+
+	return nil
+}
+
+// SetMultiple stores multiple key-value pairs with expiration
+func (c *RedisStore[V]) SetMultiple(ctx context.Context, items map[string]V, expiration time.Duration) error {
+	if len(items) == 0 {
+		return nil
+	}
+
+	return c.setMultiple(ctx, items, expiration)
+}
+
+func (c *RedisStore[V]) setMultiple(ctx context.Context, items map[string]V, expiration time.Duration) error {
+	pipe := c.client.Pipeline()
+
+	for key, value := range items {
+		data, err := marshalValue(key, value)
+		if err != nil {
+			return err
+		}
+
+		pipe.Set(ctx, key, data, expiration)
+	}
+
+	_, err := pipe.Exec(ctx)
+	if err != nil {
+		return fmt.Errorf("failed to set multiple keys: %w", err)
+	}
+
+	return nil
+}
+
+func marshalValue(key string, value interface{}) ([]byte, error) {
+	data, err := json.Marshal(value)
+	if err != nil {
+		if str, ok := value.(string); ok {
+			return []byte(str), nil
+		}
+
+		return nil, fmt.Errorf("failed to marshal value for key %s: %w", key, err)
+	}
+
+	return data, nil
+}
+
+// DeleteMultiple removes multiple keys from store
+func (c *RedisStore[V]) DeleteMultiple(ctx context.Context, keys ...string) error {
+	if len(keys) == 0 {
+		return nil
+	}
+
+	return c.deleteMultiple(ctx, keys...)
+}
+
+func (c *RedisStore[V]) deleteMultiple(ctx context.Context, keys ...string) error {
+	if len(keys) == 0 {
+		return nil
+	}
+
+	err := c.client.Del(ctx, keys...).Err()
+	if err != nil {
+		return fmt.Errorf("failed to delete multiple keys: %w", err)
+	}
+
+	return nil
+}
+
+// DeletePattern removes all keys matching the pattern from store
+func (c *RedisStore[V]) DeletePattern(ctx context.Context, pattern string) error {
+	return c.deletePattern(ctx, pattern)
+}
+
+func (c *RedisStore[V]) deletePattern(ctx context.Context, pattern string) error {
+	var cursor uint64
+
+	for {
+		var keys []string
+		var err error
+
+		// Use SCAN to find keys matching the pattern (non-blocking)
+		keys, cursor, err = c.client.Scan(ctx, cursor, pattern, 100).Result()
+		if err != nil {
+			return fmt.Errorf("failed to scan keys with pattern %s: %w", pattern, err)
+		}
+
+		// Delete found keys
+		if len(keys) > 0 {
+			err = c.client.Del(ctx, keys...).Err()
+			if err != nil {
+				return fmt.Errorf("failed to delete keys matching pattern %s: %w", pattern, err)
+			}
+		}
+
+		// If cursor is 0, we've scanned all keys
+		if cursor == 0 {
+			break
+		}
+	}
+
+	return nil
+}

pkg/store/store.go

@@ -0,0 +1,41 @@
+package store
+
+import (
+	"context"
+	"time"
+)
+
+type Store[V any] interface {
+	// Get retrieves a value from store by key
+	Get(ctx context.Context, key string) (V, bool, error)
+
+	// Set stores a value in store with expiration
+	Set(ctx context.Context, key string, value V, expiration time.Duration) error
+
+	// Delete removes a key from store
+	Delete(ctx context.Context, key string) error
+
+	// Exists checks if a key exists in store
+	Exists(ctx context.Context, key string) (bool, error)
+
+	// SetNX sets a value only if the key doesn't exist (atomic operation)
+	SetNX(ctx context.Context, key string, value V, expiration time.Duration) (bool, error)
+
+	// HMGet retrieves multiple fields from a hash
+	HMGet(ctx context.Context, key string, fields ...string) (map[string]V, error)
+
+	// HGetAll retrieves all available fields from a hash
+	HGetAll(ctx context.Context, key string) (map[string]V, error)
+
+	// HMSet sets multiple fields in a hash with expiration
+	HMSet(ctx context.Context, key string, values map[string]V, expiration time.Duration) error
+
+	// SetMultiple stores multiple key-value pairs with expiration
+	SetMultiple(ctx context.Context, items map[string]V, expiration time.Duration) error
+
+	// DeleteMultiple removes multiple keys from store
+	DeleteMultiple(ctx context.Context, keys ...string) error
+
+	// DeletePattern removes all keys matching the pattern from store
+	DeletePattern(ctx context.Context, pattern string) error
+}

pkg/store/utils.go

@@ -0,0 +1,48 @@
+package store
+
+import (
+	"encoding/json"
+	"fmt"
+	"strings"
+)
+
+// serializeValue converts a value to a string format suitable for Redis hash storage
+func serializeValue[T any](value any) (T, error) {
+	var t T
+
+	if value == nil {
+		return t, nil
+	}
+
+	if val, ok := value.(T); ok {
+		return val, nil
+	}
+
+	val, ok := value.(string)
+	if !ok {
+		return t, fmt.Errorf("invalid type %T", value)
+	}
+
+	unmarshalErr := json.Unmarshal([]byte(val), &t)
+	if unmarshalErr != nil {
+		return t, unmarshalErr
+	}
+
+	return t, nil
+}
+
+// extractKeyPattern extracts the appropriate key pattern for metrics
+// Handles both 2-part (prefix:hash) and 3-part (prefix:service:hash) keys
+func extractKeyPattern(key string) (string, error) {
+	keyPattern := strings.Split(key, ":")
+	if len(keyPattern) < 2 {
+		return "", fmt.Errorf("invalid key: %s", key)
+	}
+
+	// For 2-part keys (prefix:hash), use the prefix
+	// For 3-part keys (prefix:service:hash), use the service name
+	if len(keyPattern) == 2 {
+		return keyPattern[0], nil // prefix
+	}
+	return keyPattern[1], nil // service
+}

pkg/validation/generic_validator.go

@@ -0,0 +1,613 @@
+package validation
+
+import (
+	"encoding/json"
+	"fmt"
+	"math"
+	"net/mail"
+	"net/url"
+	"reflect"
+	"strconv"
+	"strings"
+
+	"github.com/google/uuid"
+)
+
+// ErrorResponse represents the final error response format
+type ErrorResponse struct {
+	Errors map[string]string `json:"errors"`
+}
+
+// ErrorMessage represents error message constants
+type ErrorMessage string
+
+const (
+	MissingFieldError       ErrorMessage = "This field is missing."
+	NotExpectedField        ErrorMessage = "There is unexpected field."
+	StringFieldError        ErrorMessage = "This field must be a string."
+	BoolFieldError          ErrorMessage = "This field must be a boolean."
+	NotBlankError           ErrorMessage = "This field cannot be blank."
+	IntFieldError           ErrorMessage = "This field must be an integer."
+	FloatFieldError         ErrorMessage = "این مقدار باید از نوع عدد باشد."
+	MaxRangeError           ErrorMessage = "این مقدار باید کوچکتر و یا مساوی %v باشد."
+	MinRangeError           ErrorMessage = "این مقدار باید بزرگتر و یا مساوی %v باشد."
+	AtLeastOneOfError       ErrorMessage = "At least one of the following fields must be present: '%s'."
+	SendingInformationError ErrorMessage = "{\"status\": false, \"error\": {\"code\": 500, \"message\": \"Error sending information\"}}"
+	BadRequest              ErrorMessage = "Bad Request"
+	ArrayFieldError         ErrorMessage = "This field must be an array."
+	EmailFieldError         ErrorMessage = "This field must be a valid email address."
+	PatternFieldError       ErrorMessage = "This field must contain '%s'."
+	UUIDFieldError          ErrorMessage = "This field must be a valid UUID."
+	URLFieldError           ErrorMessage = "This field must be a valid URL."
+)
+
+type ValidationTypes string
+
+const (
+	ValidationTypeString ValidationTypes = "string"
+	ValidationTypeInt    ValidationTypes = "int"
+	ValidationTypeFloat  ValidationTypes = "float"
+	ValidationTypeBool   ValidationTypes = "bool"
+	ValidationTypeEmail  ValidationTypes = "email"
+	ValidationTypeArray  ValidationTypes = "array"
+	ValidationTypeEmpty  ValidationTypes = ""
+	ValidationTypeUUID   ValidationTypes = "uuid"
+	ValidationTypeURL    ValidationTypes = "url"
+)
+
+// GenericValidator provides generic validation functions
+type GenericValidator struct {
+	errors map[string]string
+}
+
+// NewGenericValidator creates a new generic validator
+func NewGenericValidator() *GenericValidator {
+	return &GenericValidator{
+		errors: make(map[string]string),
+	}
+}
+
+// Rule defines a validation rule
+type Rule struct {
+	Field     string
+	Path      string
+	Type      ValidationTypes
+	Required  bool
+	Min       *float64
+	Max       *float64
+	MinLength *int
+	MaxLength *int
+	Pattern   *string
+	Custom    func(value interface{}) error
+	Nested    Schema // For nested object validation
+	ArrayOf   Schema // For array of objects validation
+
+	// Custom error messages
+	RequiredMessage  string
+	TypeMessage      string
+	MinMessage       string
+	MaxMessage       string
+	MinLengthMessage string
+	MaxLengthMessage string
+	PatternMessage   string
+}
+
+// Schema ValidationSchema defines validation rules for a structure
+type Schema map[string]Rule
+
+// Validate validates data against a schema
+func (gv *GenericValidator) Validate(data map[string]interface{}, schema Schema) {
+	gv.errors = make(map[string]string)
+
+	for field, rule := range schema {
+		value, exists := data[field]
+		path := rule.Path
+		if path == "" {
+			path = fmt.Sprintf("[%s]", field)
+		}
+
+		// Check if field is required
+		if rule.Required {
+			if !exists {
+				message := rule.RequiredMessage
+				if message == "" {
+					message = string(MissingFieldError)
+				}
+				gv.addError(path, message)
+				continue
+			}
+			if value == nil {
+				message := rule.RequiredMessage
+				if message == "" {
+					message = string(NotBlankError)
+				}
+				gv.addError(path, message)
+				continue
+			}
+		}
+
+		// Skip validation if field doesn't exist and is not required
+		if !exists {
+			continue
+		}
+
+		// Type validation
+		if rule.Type != ValidationTypeEmpty {
+			if err := gv.validateType(value, rule.Type, path, rule.TypeMessage); err != nil {
+				gv.addError(path, err.Error())
+				continue // Skip further validations if type is incorrect
+			}
+		}
+
+		// Range validation for numbers
+		if rule.Min != nil || rule.Max != nil {
+			if err := gv.validateRange(value, rule.Min, rule.Max, path, rule.MinMessage, rule.MaxMessage); err != nil {
+				gv.addError(path, err.Error())
+				continue
+			}
+		}
+
+		// Length validation for strings and arrays
+		if rule.MinLength != nil || rule.MaxLength != nil {
+			if err := gv.validateLength(value, rule.MinLength, rule.MaxLength, path); err != nil {
+				gv.addError(path, err.Error())
+				continue
+			}
+		}
+
+		// Pattern validation for strings
+		if rule.Pattern != nil {
+			if err := gv.validatePattern(value, *rule.Pattern, path); err != nil {
+				gv.addError(path, err.Error())
+				continue
+			}
+		}
+
+		// Custom validation
+		if rule.Custom != nil {
+			if err := rule.Custom(value); err != nil {
+				gv.addError(path, err.Error())
+			}
+		}
+
+		// Nested object validation
+		if rule.Nested != nil {
+			if nestedMap, ok := value.(map[string]interface{}); ok {
+				gv.validateNestedMap(nestedMap, rule.Nested, path)
+			}
+		}
+
+		// Array of objects validation
+		if rule.ArrayOf != nil {
+			if array, ok := value.([]interface{}); ok {
+				for i, item := range array {
+					if itemMap, ok := item.(map[string]interface{}); ok {
+						itemPath := fmt.Sprintf("%s[%d]", path, i)
+						gv.validateNestedMap(itemMap, rule.ArrayOf, itemPath)
+					}
+				}
+			}
+		}
+	}
+}
+
+// ValidateNested validates nested structures
+func (gv *GenericValidator) ValidateNested(data interface{}, schema Schema, basePath string) {
+	switch v := data.(type) {
+	case map[string]interface{}:
+		gv.validateNestedMap(v, schema, basePath)
+	case []interface{}:
+		gv.validateNestedSlice(v, schema, basePath)
+	}
+}
+
+// validateNestedMap validates nested map structures
+func (gv *GenericValidator) validateNestedMap(data map[string]interface{}, schema Schema, basePath string) {
+	for field, rule := range schema {
+		value, exists := data[field]
+		path := rule.Path
+		if path == "" {
+			path = fmt.Sprintf("%s[%s]", basePath, field)
+		}
+
+		// Check if field is required
+		if rule.Required {
+			if !exists {
+				message := rule.RequiredMessage
+				if message == "" {
+					message = string(MissingFieldError)
+				}
+				gv.addError(path, message)
+				continue
+			}
+			if value == nil {
+				message := rule.RequiredMessage
+				if message == "" {
+					message = string(NotBlankError)
+				}
+				gv.addError(path, message)
+				continue
+			}
+		}
+
+		// Skip validation if field doesn't exist and is not required
+		if !exists {
+			continue
+		}
+
+		// Type validation
+		if rule.Type != ValidationTypeEmpty {
+			if err := gv.validateType(value, rule.Type, path, rule.TypeMessage); err != nil {
+				gv.addError(path, err.Error())
+				continue // Skip further validations if type is incorrect
+			}
+		}
+
+		// Range validation for numbers
+		if rule.Min != nil || rule.Max != nil {
+			if err := gv.validateRange(value, rule.Min, rule.Max, path, rule.MinMessage, rule.MaxMessage); err != nil {
+				gv.addError(path, err.Error())
+				continue
+			}
+		}
+
+		// Length validation for strings and arrays
+		if rule.MinLength != nil || rule.MaxLength != nil {
+			if err := gv.validateLength(value, rule.MinLength, rule.MaxLength, path); err != nil {
+				gv.addError(path, err.Error())
+				continue
+			}
+		}
+
+		// Pattern validation for strings
+		if rule.Pattern != nil {
+			if err := gv.validatePattern(value, *rule.Pattern, path); err != nil {
+				gv.addError(path, err.Error())
+				continue
+			}
+		}
+
+		// Custom validation
+		if rule.Custom != nil {
+			if err := rule.Custom(value); err != nil {
+				gv.addError(path, err.Error())
+			}
+		}
+	}
+}
+
+// validateNestedSlice validates nested slice structures
+func (gv *GenericValidator) validateNestedSlice(data []interface{}, schema Schema, basePath string) {
+	for i, item := range data {
+		if itemMap, ok := item.(map[string]interface{}); ok {
+			itemPath := fmt.Sprintf("%s[%d]", basePath, i)
+			gv.validateNestedMap(itemMap, schema, itemPath)
+		}
+	}
+}
+
+func (gv *GenericValidator) validateString(value any, customErrMsg string) error {
+	if reflect.TypeOf(value).Kind() != reflect.String {
+		if customErrMsg != "" {
+			return fmt.Errorf("%s", customErrMsg)
+		}
+		return fmt.Errorf(string(StringFieldError))
+	}
+	return nil
+}
+
+// validateType validates the type of value
+func (gv *GenericValidator) validateType(value interface{}, expectedType ValidationTypes, path string, customErrMsg string) error {
+	switch expectedType {
+	case ValidationTypeString:
+		if err := gv.validateString(value, customErrMsg); err != nil {
+			return err
+		}
+	case ValidationTypeInt:
+		if val, ok := value.(float64); ok {
+			if val != float64(int(val)) || val > float64(math.MaxUint32) {
+				if customErrMsg != "" {
+					return fmt.Errorf("%s", customErrMsg)
+				}
+				return fmt.Errorf(string(IntFieldError))
+			}
+		} else {
+			if customErrMsg != "" {
+				return fmt.Errorf("%s", customErrMsg)
+			}
+			return fmt.Errorf(string(IntFieldError))
+		}
+	case ValidationTypeFloat:
+		if _, ok := value.(float64); !ok {
+			if customErrMsg != "" {
+				return fmt.Errorf("%s", customErrMsg)
+			}
+			return fmt.Errorf(string(FloatFieldError))
+		}
+	case ValidationTypeBool:
+		if reflect.TypeOf(value).Kind() != reflect.Bool {
+			if customErrMsg != "" {
+				return fmt.Errorf("%s", customErrMsg)
+			}
+			return fmt.Errorf(string(BoolFieldError))
+		}
+	case ValidationTypeArray:
+		if reflect.TypeOf(value).Kind() != reflect.Slice {
+			if customErrMsg != "" {
+				return fmt.Errorf("%s", customErrMsg)
+			}
+			return fmt.Errorf(string(ArrayFieldError))
+		}
+	case ValidationTypeEmail:
+		if err := gv.validateString(value, customErrMsg); err != nil {
+			return err
+		}
+		if _, err := mail.ParseAddress(value.(string)); err != nil {
+			if customErrMsg != "" {
+				return fmt.Errorf("%s", customErrMsg)
+			}
+			return fmt.Errorf(string(EmailFieldError))
+		}
+	case ValidationTypeUUID:
+		if err := gv.validateString(value, customErrMsg); err != nil {
+			return err
+		}
+		if _, err := uuid.Parse(value.(string)); err != nil {
+			if customErrMsg != "" {
+				return fmt.Errorf("%s", customErrMsg)
+			}
+			return fmt.Errorf(string(UUIDFieldError))
+		}
+	case ValidationTypeURL:
+		if err := gv.validateString(value, customErrMsg); err != nil {
+			return err
+		}
+		if _, err := url.Parse(value.(string)); err != nil {
+			if customErrMsg != "" {
+				return fmt.Errorf("%s", customErrMsg)
+			}
+			return fmt.Errorf(string(URLFieldError))
+		}
+	}
+
+	return nil
+}
+
+// validateRange validates numeric range
+func (gv *GenericValidator) validateRange(value interface{}, min, max *float64, path string, minMessage, maxMessage string) error {
+	var num float64
+
+	switch v := value.(type) {
+	case float64:
+		num = v
+	case int:
+		num = float64(v)
+	case string:
+		if parsed, err := strconv.ParseFloat(v, 64); err == nil {
+			num = parsed
+		} else {
+			return fmt.Errorf(string(FloatFieldError))
+		}
+	default:
+		return fmt.Errorf(string(FloatFieldError))
+	}
+
+	if min != nil && num < *min {
+		if minMessage != "" {
+			return fmt.Errorf("%s", minMessage)
+		}
+		return fmt.Errorf(string(MinRangeError), *min)
+	}
+
+	if max != nil && num > *max {
+		if maxMessage != "" {
+			return fmt.Errorf("%s", maxMessage)
+		}
+		return fmt.Errorf(string(MaxRangeError), *max)
+	}
+
+	return nil
+}
+
+// validateLength validates string or array length
+func (gv *GenericValidator) validateLength(value interface{}, minLength, maxLength *int, path string) error {
+	var length int
+	var isArray bool
+
+	switch v := value.(type) {
+	case string:
+		length = len(v)
+		isArray = false
+	case []interface{}:
+		length = len(v)
+		isArray = true
+	default:
+		return fmt.Errorf(string(StringFieldError))
+	}
+
+	if minLength != nil && length < *minLength {
+		if isArray {
+			return fmt.Errorf(string(MinRangeError), *minLength)
+		}
+		return fmt.Errorf(string(MinRangeError), *minLength)
+	}
+
+	if maxLength != nil && length > *maxLength {
+		if isArray {
+			return fmt.Errorf(string(MaxRangeError), *maxLength)
+		}
+		return fmt.Errorf(string(MaxRangeError), *maxLength)
+	}
+
+	return nil
+}
+
+// validatePattern validates string pattern (simple implementation)
+func (gv *GenericValidator) validatePattern(value interface{}, pattern string, path string) error {
+	if str, ok := value.(string); ok {
+		// Simple pattern validation - can be extended with regex
+		if !strings.Contains(str, pattern) {
+			return fmt.Errorf(string(PatternFieldError), pattern)
+		}
+	} else {
+		return fmt.Errorf(string(StringFieldError))
+	}
+	return nil
+}
+
+// addError adds an error to the validator
+func (gv *GenericValidator) addError(path, message string) {
+	gv.errors[path] = message
+}
+
+// AddError adds a custom error
+func (gv *GenericValidator) AddError(path, message string) {
+	gv.errors[path] = message
+}
+
+// GetErrors returns all validation errors
+func (gv *GenericValidator) GetErrors() map[string]string {
+	return gv.errors
+}
+
+// HasErrors returns true if there are validation errors
+func (gv *GenericValidator) HasErrors() bool {
+	return len(gv.errors) > 0
+}
+
+// ToJSON returns the errors in JSON format
+func (gv *GenericValidator) ToJSON() ([]byte, error) {
+	response := ErrorResponse{
+		Errors: gv.errors,
+	}
+	return json.Marshal(response)
+}
+
+// Convenience functions for common validations
+
+// ValidateRequired validates that a field exists and is not empty
+func (gv *GenericValidator) ValidateRequired(data map[string]interface{}, field, path string) {
+	if path == "" {
+		path = fmt.Sprintf("[%s]", field)
+	}
+
+	value, exists := data[field]
+	if !exists {
+		gv.addError(path, string(MissingFieldError))
+		return
+	}
+
+	if value == nil {
+		gv.addError(path, string(NotBlankError))
+		return
+	}
+
+	// Check for empty string
+	if str, ok := value.(string); ok && str == "" {
+		gv.addError(path, string(NotBlankError))
+		return
+	}
+
+	// Check for empty array
+	if arr, ok := value.([]interface{}); ok && len(arr) == 0 {
+		gv.addError(path, string(NotBlankError))
+		return
+	}
+}
+
+// ValidatePrice validates that a price is a positive number
+func (gv *GenericValidator) ValidatePrice(data map[string]interface{}, field, path string) {
+	if path == "" {
+		path = fmt.Sprintf("[%s]", field)
+	}
+
+	value, exists := data[field]
+	if !exists {
+		return
+	}
+
+	var num float64
+	switch v := value.(type) {
+	case float64:
+		num = v
+	case int:
+		num = float64(v)
+	case string:
+		if parsed, err := strconv.ParseFloat(v, 64); err == nil {
+			num = parsed
+		} else {
+			gv.addError(path, string(FloatFieldError))
+			return
+		}
+	default:
+		gv.addError(path, string(FloatFieldError))
+		return
+	}
+
+	if num < 1 {
+		gv.addError(path, fmt.Sprintf(string(MinRangeError), 1))
+	}
+}
+
+// ValidateQuantity validates that a quantity is a positive integer
+func (gv *GenericValidator) ValidateQuantity(data map[string]interface{}, field, path string) {
+	if path == "" {
+		path = fmt.Sprintf("[%s]", field)
+	}
+
+	value, exists := data[field]
+	if !exists {
+		return
+	}
+
+	var num float64
+	switch v := value.(type) {
+	case float64:
+		num = v
+	case int:
+		num = float64(v)
+	case string:
+		if parsed, err := strconv.ParseFloat(v, 64); err == nil {
+			num = parsed
+		} else {
+			gv.addError(path, string(FloatFieldError))
+			return
+		}
+	default:
+		gv.addError(path, string(FloatFieldError))
+		return
+	}
+
+	if num < 0 || num != float64(int(num)) {
+		gv.addError(path, string(IntFieldError))
+	}
+}
+
+// Global convenience functions
+
+// ValidateData validates data against a schema
+func ValidateData(data map[string]interface{}, schema Schema) *GenericValidator {
+	validator := NewGenericValidator()
+	validator.Validate(data, schema)
+	return validator
+}
+
+// ValidateJSONData validates JSON data against a schema
+func ValidateJSONData(jsonData []byte, schema Schema) (*GenericValidator, error) {
+	var data map[string]interface{}
+	if err := json.Unmarshal(jsonData, &data); err != nil {
+		return nil, fmt.Errorf("Invalid JSON: %v", err)
+	}
+
+	validator := NewGenericValidator()
+	validator.Validate(data, schema)
+	return validator, nil
+}
+
+func Float64Ptr(f float64) *float64 {
+	return &f
+}
+
+func IntPtr(i int) *int {
+	return &i
+}

pkg/validation/generic_validator_test.go

@@ -0,0 +1,642 @@
+package validation
+
+import (
+	"encoding/json"
+	"fmt"
+	"testing"
+)
+
+func TestNewGenericValidator(t *testing.T) {
+	validator := NewGenericValidator()
+
+	if validator == nil {
+		t.Fatal("Expected validator to be created")
+	}
+
+	if validator.errors == nil {
+		t.Fatal("Expected errors map to be initialized")
+	}
+
+	if len(validator.errors) != 0 {
+		t.Fatal("Expected empty errors map")
+	}
+}
+
+func TestGenericValidator_Validate_Required(t *testing.T) {
+	validator := NewGenericValidator()
+
+	schema := Schema{
+		"name": Rule{
+			Field:    "name",
+			Required: true,
+		},
+		"email": Rule{
+			Field:    "email",
+			Required: true,
+		},
+	}
+
+	data := map[string]interface{}{
+		"name": "John",
+		// email is missing
+	}
+
+	validator.Validate(data, schema)
+
+	if !validator.HasErrors() {
+		t.Fatal("Expected validation errors")
+	}
+
+	errors := validator.GetErrors()
+	if len(errors) != 1 {
+		t.Fatalf("Expected 1 error, got %d", len(errors))
+	}
+
+	if errors["[email]"] != "This field is missing." {
+		t.Fatalf("Expected email error, got: %s", errors["[email]"])
+	}
+}
+
+func TestGenericValidator_Validate_Type(t *testing.T) {
+	validator := NewGenericValidator()
+
+	schema := Schema{
+		"age": Rule{
+			Field: "age",
+			Type:  "int",
+		},
+		"price": Rule{
+			Field: "price",
+			Type:  "float",
+		},
+		"active": Rule{
+			Field: "active",
+			Type:  "bool",
+		},
+	}
+
+	data := map[string]interface{}{
+		"age":    "not a number",
+		"price":  "invalid",
+		"active": "not boolean",
+	}
+
+	validator.Validate(data, schema)
+
+	if !validator.HasErrors() {
+		t.Fatal("Expected validation errors")
+	}
+
+	errors := validator.GetErrors()
+	if len(errors) != 3 {
+		t.Fatalf("Expected 3 errors, got %d", len(errors))
+	}
+}
+
+func TestGenericValidator_Validate_Range(t *testing.T) {
+	validator := NewGenericValidator()
+
+	min := 1.0
+	max := 100.0
+
+	schema := Schema{
+		"score": Rule{
+			Field: "score",
+			Min:   &min,
+			Max:   &max,
+		},
+	}
+
+	data := map[string]interface{}{
+		"score": 0.5, // below min
+	}
+
+	validator.Validate(data, schema)
+
+	if !validator.HasErrors() {
+		t.Fatal("Expected validation errors")
+	}
+
+	errors := validator.GetErrors()
+	if len(errors) != 1 {
+		t.Fatalf("Expected 1 error, got %d", len(errors))
+	}
+
+	if errors["[score]"] != "این مقدار باید بزرگتر و یا مساوی 1 باشد." {
+		t.Fatalf("Expected range error, got: %s", errors["[score]"])
+	}
+}
+
+func TestGenericValidator_Validate_Length(t *testing.T) {
+	validator := NewGenericValidator()
+
+	minLength := 3
+	maxLength := 10
+
+	schema := Schema{
+		"name": Rule{
+			Field:     "name",
+			MinLength: &minLength,
+			MaxLength: &maxLength,
+		},
+		"tags": Rule{
+			Field:     "tags",
+			MinLength: &minLength,
+			MaxLength: &maxLength,
+		},
+	}
+
+	data := map[string]interface{}{
+		"name": "ab",                          // too short
+		"tags": []interface{}{"tag1", "tag2"}, // too few
+	}
+
+	validator.Validate(data, schema)
+
+	if !validator.HasErrors() {
+		t.Fatal("Expected validation errors")
+	}
+
+	errors := validator.GetErrors()
+	if len(errors) != 2 {
+		t.Fatalf("Expected 2 errors, got %d", len(errors))
+	}
+}
+
+func TestGenericValidator_Validate_Custom(t *testing.T) {
+	validator := NewGenericValidator()
+
+	schema := Schema{
+		"code": Rule{
+			Field: "code",
+			Custom: func(value interface{}) error {
+				if str, ok := value.(string); ok {
+					if len(str) != 6 {
+						return fmt.Errorf("کد باید 6 کاراکتر باشد.")
+					}
+				}
+				return nil
+			},
+		},
+	}
+
+	data := map[string]interface{}{
+		"code": "12345", // too short
+	}
+
+	validator.Validate(data, schema)
+
+	if !validator.HasErrors() {
+		t.Fatal("Expected validation errors")
+	}
+
+	errors := validator.GetErrors()
+	if len(errors) != 1 {
+		t.Fatalf("Expected 1 error, got %d", len(errors))
+	}
+
+	if errors["[code]"] != "کد باید 6 کاراکتر باشد." {
+		t.Fatalf("Expected custom error, got: %s", errors["[code]"])
+	}
+}
+
+func TestGenericValidator_ValidateNested(t *testing.T) {
+	validator := NewGenericValidator()
+
+	schema := Schema{
+		"name": Rule{
+			Field:    "name",
+			Required: true,
+		},
+		"age": Rule{
+			Field: "age",
+			Type:  "int",
+		},
+	}
+
+	nestedData := map[string]interface{}{
+		"users": []interface{}{
+			map[string]interface{}{
+				"name": "John",
+				"age":  "not a number",
+			},
+			map[string]interface{}{
+				// name is missing
+				"age": 25,
+			},
+		},
+	}
+
+	validator.ValidateNested(nestedData["users"], schema, "[users]")
+
+	if !validator.HasErrors() {
+		t.Fatal("Expected validation errors")
+	}
+
+	errors := validator.GetErrors()
+	if len(errors) != 3 {
+		t.Fatalf("Expected 3 errors, got %d", len(errors))
+	}
+
+	// Check for expected errors
+	expectedErrors := map[string]bool{
+		"[users][0][age]":  true, // age is string instead of int
+		"[users][1][name]": true, // name is missing (required)
+		"[users][1][age]":  true, // age is int (valid)
+	}
+
+	for path := range errors {
+		if !expectedErrors[path] {
+			t.Fatalf("Unexpected error path: %s", path)
+		}
+	}
+}
+
+func TestGenericValidator_ValidateRequired(t *testing.T) {
+	validator := NewGenericValidator()
+
+	data := map[string]interface{}{
+		"name":    "John",
+		"email":   "",
+		"tags":    []interface{}{},
+		"missing": nil,
+	}
+
+	validator.ValidateRequired(data, "name", "[name]")
+	validator.ValidateRequired(data, "email", "[email]")
+	validator.ValidateRequired(data, "tags", "[tags]")
+	validator.ValidateRequired(data, "missing", "[missing]")
+
+	if !validator.HasErrors() {
+		t.Fatal("Expected validation errors")
+	}
+
+	errors := validator.GetErrors()
+	if len(errors) != 3 {
+		t.Fatalf("Expected 3 errors, got %d", len(errors))
+	}
+}
+
+func TestGenericValidator_ValidatePrice(t *testing.T) {
+	validator := NewGenericValidator()
+
+	data := map[string]interface{}{
+		"price1": 100.0,
+		"price2": 0.5,
+		"price3": "invalid",
+		"price4": -10.0,
+	}
+
+	validator.ValidatePrice(data, "price1", "[price1]")
+	validator.ValidatePrice(data, "price2", "[price2]")
+	validator.ValidatePrice(data, "price3", "[price3]")
+	validator.ValidatePrice(data, "price4", "[price4]")
+
+	if !validator.HasErrors() {
+		t.Fatal("Expected validation errors")
+	}
+
+	errors := validator.GetErrors()
+	if len(errors) != 3 {
+		t.Fatalf("Expected 3 errors, got %d", len(errors))
+	}
+}
+
+func TestGenericValidator_ValidateQuantity(t *testing.T) {
+	validator := NewGenericValidator()
+
+	data := map[string]interface{}{
+		"qty1": 10,
+		"qty2": -5,
+		"qty3": 3.5,
+		"qty4": "invalid",
+	}
+
+	validator.ValidateQuantity(data, "qty1", "[qty1]")
+	validator.ValidateQuantity(data, "qty2", "[qty2]")
+	validator.ValidateQuantity(data, "qty3", "[qty3]")
+	validator.ValidateQuantity(data, "qty4", "[qty4]")
+
+	if !validator.HasErrors() {
+		t.Fatal("Expected validation errors")
+	}
+
+	errors := validator.GetErrors()
+	if len(errors) != 3 {
+		t.Fatalf("Expected 3 errors, got %d", len(errors))
+	}
+}
+
+func TestGenericValidator_ToJSON(t *testing.T) {
+	validator := NewGenericValidator()
+
+	validator.AddError("[name]", "این فیلد الزامی است.")
+	validator.AddError("[email]", "ایمیل نامعتبر است.")
+
+	jsonData, err := validator.ToJSON()
+	if err != nil {
+		t.Fatalf("Expected no error, got: %v", err)
+	}
+
+	var response ErrorResponse
+	if err := json.Unmarshal(jsonData, &response); err != nil {
+		t.Fatalf("Expected valid JSON, got: %v", err)
+	}
+
+	if len(response.Errors) != 2 {
+		t.Fatalf("Expected 2 errors, got %d", len(response.Errors))
+	}
+
+	if response.Errors["[name]"] != "این فیلد الزامی است." {
+		t.Fatalf("Expected name error, got: %s", response.Errors["[name]"])
+	}
+}
+
+func TestValidateData(t *testing.T) {
+	schema := Schema{
+		"name": Rule{
+			Field:    "name",
+			Required: true,
+		},
+		"age": Rule{
+			Field: "age",
+			Type:  "int",
+		},
+	}
+
+	data := map[string]interface{}{
+		"name": "John",
+		"age":  "not a number",
+	}
+
+	validator := ValidateData(data, schema)
+
+	if !validator.HasErrors() {
+		t.Fatal("Expected validation errors")
+	}
+
+	errors := validator.GetErrors()
+	if len(errors) != 1 {
+		t.Fatalf("Expected 1 error, got %d", len(errors))
+	}
+}
+
+func TestValidateJSONData(t *testing.T) {
+	schema := Schema{
+		"name": Rule{
+			Field:    "name",
+			Required: true,
+		},
+	}
+
+	jsonData := []byte(`{"name": "John"}`)
+
+	validator, err := ValidateJSONData(jsonData, schema)
+	if err != nil {
+		t.Fatalf("Expected no error, got: %v", err)
+	}
+
+	if validator.HasErrors() {
+		t.Fatal("Expected no validation errors")
+	}
+
+	// Test invalid JSON
+	invalidJSON := []byte(`{"name": "John"`)
+
+	_, err = ValidateJSONData(invalidJSON, schema)
+	if err == nil {
+		t.Fatal("Expected JSON parsing error")
+	}
+}
+
+func TestGenericValidator_ComplexNestedValidation(t *testing.T) {
+	validator := NewGenericValidator()
+
+	// Schema for user object
+	userSchema := Schema{
+		"name": Rule{
+			Field:    "name",
+			Required: true,
+		},
+		"age": Rule{
+			Field: "age",
+			Type:  "int",
+		},
+		"email": Rule{
+			Field: "email",
+			Type:  "string",
+		},
+	}
+
+	// Complex nested data
+	data := map[string]interface{}{
+		"users": []interface{}{
+			map[string]interface{}{
+				"name":  "John",
+				"age":   25,
+				"email": "john@example.com",
+			},
+			map[string]interface{}{
+				"name":  "Jane",
+				"age":   "not a number",
+				"email": "jane@example.com",
+			},
+			map[string]interface{}{
+				// missing name
+				"age":   30,
+				"email": "bob@example.com",
+			},
+		},
+		"settings": map[string]interface{}{
+			"theme": "dark",
+			"lang":  "en",
+		},
+	}
+
+	// Validate nested users array
+	validator.ValidateNested(data["users"], userSchema, "[users]")
+
+	if !validator.HasErrors() {
+		t.Fatal("Expected validation errors")
+	}
+
+	errors := validator.GetErrors()
+	if len(errors) != 4 {
+		t.Fatalf("Expected 4 errors, got %d: %v", len(errors), errors)
+	}
+
+	// Check specific errors
+	expectedErrors := map[string]bool{
+		"[users][1][age]":  true, // age is string instead of int
+		"[users][2][name]": true, // name is missing (required)
+		"[users][0][age]":  true, // age is int (valid)
+		"[users][0][name]": true, // name is string (valid)
+		"[users][2][age]":  true, // age is int (valid)
+	}
+
+	for path := range errors {
+		if !expectedErrors[path] {
+			t.Fatalf("Unexpected error path: %s", path)
+		}
+	}
+}
+
+func TestGenericValidator_NoErrors(t *testing.T) {
+	validator := NewGenericValidator()
+
+	schema := Schema{
+		"name": Rule{
+			Field:    "name",
+			Required: true,
+		},
+		"age": Rule{
+			Field: "age",
+			Type:  "int",
+		},
+	}
+
+	data := map[string]interface{}{
+		"name": "John",
+		"age":  25.0, // Use float64 to match JSON unmarshaling
+	}
+
+	validator.Validate(data, schema)
+
+	if validator.HasErrors() {
+		errors := validator.GetErrors()
+		t.Fatalf("Expected no validation errors, got: %v", errors)
+	}
+
+	errors := validator.GetErrors()
+	if len(errors) != 0 {
+		t.Fatalf("Expected 0 errors, got %d", len(errors))
+	}
+}
+
+func TestGenericValidator_EnqueueVendorStocksRequest(t *testing.T) {
+	itemSchema := Schema{
+		"barcode": Rule{
+			Field:     "barcode",
+			Type:      "string",
+			Required:  true,
+			MinLength: func() *int { i := 1; return &i }(),
+		},
+		"stock": Rule{
+			Field:    "stock",
+			Type:     "int",
+			Required: true,
+		},
+	}
+	schema := Schema{
+		"stocks": Rule{
+			Field:     "stocks",
+			Type:      "array",
+			Required:  true,
+			MinLength: func() *int { i := 1; return &i }(),
+			ArrayOf:   itemSchema,
+		},
+	}
+
+	// Valid payload
+	valid := map[string]interface{}{
+		"vendorId":   123,
+		"vendorCode": "VEND123",
+		"stocks": []interface{}{
+			map[string]interface{}{
+				"barcode": "1234567890",
+				"stock":   10.0,
+			},
+			map[string]interface{}{
+				"barcode": "0987654321",
+				"stock":   5.0,
+			},
+		},
+	}
+	validator := NewGenericValidator()
+	validator.Validate(valid, schema)
+	if validator.HasErrors() {
+		t.Fatalf("Expected no validation errors, got: %v", validator.GetErrors())
+	}
+
+	// Invalid payload: missing items, empty barcode, non-int stock
+	invalid := map[string]interface{}{
+		"stocks": []interface{}{
+			map[string]interface{}{
+				"barcode": "",
+				"stock":   "not-an-int",
+			},
+		},
+	}
+	validator = NewGenericValidator()
+	validator.Validate(invalid, schema)
+	if !validator.HasErrors() {
+		t.Fatal("Expected validation errors")
+	}
+	errors := validator.GetErrors()
+	if len(errors) != 2 {
+		t.Fatalf("Expected 2 errors, got %d: %v", len(errors), errors)
+	}
+	if _, ok := errors["[stocks][0][barcode]"]; !ok {
+		t.Error("Expected error for empty barcode")
+	}
+	if _, ok := errors["[stocks][0][stock]"]; !ok {
+		t.Error("Expected error for non-int stock")
+	}
+}
+
+func TestGenericValidator_CustomErrorMessages(t *testing.T) {
+	schema := Schema{
+		"name": Rule{
+			Field:           "name",
+			Type:            "string",
+			Required:        true,
+			RequiredMessage: "نام کاربر الزامی است.",
+			TypeMessage:     "نام باید از نوع متن باشد.",
+		},
+		"age": Rule{
+			Field:       "age",
+			Type:        "int",
+			Min:         func() *float64 { f := 18.0; return &f }(),
+			Max:         func() *float64 { f := 100.0; return &f }(),
+			MinMessage:  "سن باید حداقل 18 سال باشد.",
+			MaxMessage:  "سن نمی تواند بیشتر از 100 سال باشد.",
+			TypeMessage: "سن باید عدد صحیح باشد.",
+		},
+		"email": Rule{
+			Field:           "email",
+			Type:            "string",
+			Required:        true,
+			RequiredMessage: "ایمیل الزامی است.",
+			PatternMessage:  "فرمت ایمیل نامعتبر است.",
+		},
+	}
+
+	// Test with invalid data
+	data := map[string]interface{}{
+		"name": 123,       // wrong type
+		"age":  "invalid", // wrong type
+		// email is missing (not empty)
+	}
+
+	validator := NewGenericValidator()
+	validator.Validate(data, schema)
+
+	if !validator.HasErrors() {
+		t.Fatal("Expected validation errors")
+	}
+
+	errors := validator.GetErrors()
+
+	// Check custom error messages
+	if errors["[name]"] != "نام باید از نوع متن باشد." {
+		t.Errorf("Expected custom type error for name, got: %s", errors["[name]"])
+	}
+
+	if errors["[age]"] != "سن باید عدد صحیح باشد." {
+		t.Errorf("Expected custom type error for age, got: %s", errors["[age]"])
+	}
+
+	if errors["[email]"] != "ایمیل الزامی است." {
+		t.Errorf("Expected custom required error for email, got: %s", errors["[email]"])
+	}
+}

pkg/validation/struct_validator.go

@@ -0,0 +1,185 @@
+package validation
+
+import (
+	"encoding/json"
+	"fmt"
+	"reflect"
+	"strconv"
+	"strings"
+)
+
+// StructValidator validates a struct using individual validation functions
+type StructValidator struct {
+	errors []error
+}
+
+// NewStructValidator creates a new struct validator
+func NewStructValidator() *StructValidator {
+	return &StructValidator{
+		errors: make([]error, 0),
+	}
+}
+
+// Validate validates a struct and returns all validation errors
+func (sv *StructValidator) Validate(data map[string]interface{}, structType interface{}) []error {
+	sv.errors = make([]error, 0)
+
+	// Get struct type information
+	val := reflect.ValueOf(structType)
+	if val.Kind() == reflect.Ptr {
+		val = val.Elem()
+	}
+	typ := val.Type()
+
+	// Build expected fields map
+	expectedFields := make(map[string]struct{})
+	requiredFields := make(map[string]struct{})
+	fieldValidations := make(map[string]map[string]string)
+
+	// Extract field information from struct tags
+	for i := 0; i < typ.NumField(); i++ {
+		field := typ.Field(i)
+		jsonTag := field.Tag.Get("json")
+		validateTag := field.Tag.Get("validate")
+		minTag := field.Tag.Get("min")
+		maxTag := field.Tag.Get("max")
+
+		if jsonTag != "" && jsonTag != "-" {
+			expectedFields[jsonTag] = struct{}{}
+
+			// Store validations for this field
+			fieldValidations[jsonTag] = make(map[string]string)
+			if validateTag != "" {
+				fieldValidations[jsonTag]["validate"] = validateTag
+			}
+			if minTag != "" {
+				fieldValidations[jsonTag]["min"] = minTag
+			}
+			if maxTag != "" {
+				fieldValidations[jsonTag]["max"] = maxTag
+			}
+
+			// Check if field is required
+			if strings.Contains(validateTag, "required") {
+				requiredFields[jsonTag] = struct{}{}
+			}
+		}
+	}
+
+	// Validate required fields exist
+	for field := range requiredFields {
+		if err := ExistKey(field, data, fmt.Sprintf("Field '%s' is required", field)); err != nil {
+			sv.errors = append(sv.errors, err)
+		}
+	}
+
+	// Validate each field in the data
+	for key, value := range data {
+		// Check for unexpected fields
+		if _, ok := expectedFields[key]; !ok {
+			err := ErrBadRequest.SetMessage(fmt.Sprintf("Unexpected field '%s'", key))
+			sv.errors = append(sv.errors, err)
+			continue
+		}
+
+		// Get field validations
+		validations, exists := fieldValidations[key]
+		if !exists {
+			continue
+		}
+
+		// Apply validations based on struct tags
+		sv.applyFieldValidations(key, value, data, validations)
+	}
+
+	return sv.errors
+}
+
+// applyFieldValidations applies all validations for a specific field
+func (sv *StructValidator) applyFieldValidations(key string, value interface{}, data map[string]interface{}, validations map[string]string) {
+	// Check if field is required
+	if validateTag, ok := validations["validate"]; ok && strings.Contains(validateTag, "required") {
+		if err := NotBlank(key, data, fmt.Sprintf("Field '%s' cannot be blank", key)); err != nil {
+			sv.errors = append(sv.errors, err)
+		}
+	}
+
+	// Type validations
+	if value != nil {
+		switch value.(type) {
+		case string:
+			if err := IsString(key, data, fmt.Sprintf("Field '%s' must be a string", key)); err != nil {
+				sv.errors = append(sv.errors, err)
+			}
+		case float64:
+			// Check if it's an integer
+			if validateTag, ok := validations["validate"]; ok && strings.Contains(validateTag, "int") {
+				if err := IsInt(key, data, fmt.Sprintf("Field '%s' must be an integer", key)); err != nil {
+					sv.errors = append(sv.errors, err)
+				}
+			} else {
+				if err := IsFloat64(key, data, fmt.Sprintf("Field '%s' must be a number", key)); err != nil {
+					sv.errors = append(sv.errors, err)
+				}
+			}
+		case bool:
+			if err := IsBool(key, data, fmt.Sprintf("Field '%s' must be a boolean", key)); err != nil {
+				sv.errors = append(sv.errors, err)
+			}
+		case []interface{}:
+			// Slice validation - could be extended for specific slice types
+			if validateTag, ok := validations["validate"]; ok && strings.Contains(validateTag, "required") {
+				if err := NotBlank(key, data, fmt.Sprintf("Field '%s' cannot be empty", key)); err != nil {
+					sv.errors = append(sv.errors, err)
+				}
+			}
+		}
+	}
+
+	// Range validations
+	if minTag, ok := validations["min"]; ok {
+		if min, err := strconv.Atoi(minTag); err == nil {
+			if err := MinRange(key, min, data, fmt.Sprintf("Field '%s' must be at least %d", key, min)); err != nil {
+				sv.errors = append(sv.errors, err)
+			}
+		}
+	}
+
+	if maxTag, ok := validations["max"]; ok {
+		if max, err := strconv.Atoi(maxTag); err == nil {
+			if err := MaxRange(key, max, data, fmt.Sprintf("Field '%s' must be at most %d", key, max)); err != nil {
+				sv.errors = append(sv.errors, err)
+			}
+		}
+	}
+}
+
+// ValidateStruct is a convenience function that validates a struct directly
+func ValidateStruct(data map[string]interface{}, structType interface{}) []error {
+	validator := NewStructValidator()
+	return validator.Validate(data, structType)
+}
+
+// ValidateJSON validates JSON data against a struct
+func ValidateJSON(jsonData []byte, structType interface{}) []error {
+	var data map[string]interface{}
+	if err := json.Unmarshal(jsonData, &data); err != nil {
+		return []error{ErrBadRequest.SetMessage(fmt.Sprintf("Invalid JSON: %v", err))}
+	}
+	return ValidateStruct(data, structType)
+}
+
+// HasErrors returns true if there are validation errors
+func (sv *StructValidator) HasErrors() bool {
+	return len(sv.errors) > 0
+}
+
+// GetErrors returns all validation errors
+func (sv *StructValidator) GetErrors() []error {
+	return sv.errors
+}
+
+// AddError adds a custom error
+func (sv *StructValidator) AddError(err error) {
+	sv.errors = append(sv.errors, err)
+}

pkg/validation/struct_validator_test.go

@@ -0,0 +1,387 @@
+package validation
+
+import (
+	"strings"
+	"testing"
+)
+
+// Test structs for validation testing
+type TestStruct struct {
+	Name     string   `json:"name" validate:"required"`
+	Age      int      `json:"age" min:"18" max:"100" validate:"required,int"`
+	Height   float64  `json:"height" min:"50" max:"250"`
+	IsActive bool     `json:"is_active"`
+	Tags     []string `json:"tags" validate:"required"`
+	Email    string   `json:"email"`
+}
+
+type OptionalStruct struct {
+	Name     string  `json:"name"`
+	Age      int     `json:"age" min:"0" max:"150"`
+	Height   float64 `json:"height" min:"0" max:"300"`
+	IsActive bool    `json:"is_active"`
+}
+
+type RequiredStruct struct {
+	Name     string `json:"name" validate:"required"`
+	Email    string `json:"email" validate:"required"`
+	Age      int    `json:"age" validate:"required,int"`
+	IsActive bool   `json:"is_active" validate:"required"`
+}
+
+func TestStructValidator_Validate_ValidData(t *testing.T) {
+	data := map[string]interface{}{
+		"name":      "John Doe",
+		"age":       25.0,
+		"height":    175.5,
+		"is_active": true,
+		"tags":      []interface{}{"tag1", "tag2"},
+		"email":     "john@example.com",
+	}
+
+	var structType TestStruct
+	errors := ValidateStruct(data, structType)
+
+	if len(errors) != 0 {
+		t.Errorf("Expected no validation errors, got %d: %v", len(errors), errors)
+	}
+}
+
+func TestStructValidator_Validate_MissingRequiredField(t *testing.T) {
+	data := map[string]interface{}{
+		"age":       25.0,
+		"height":    175.5,
+		"is_active": true,
+		"tags":      []interface{}{"tag1"},
+	}
+
+	var structType TestStruct
+	errors := ValidateStruct(data, structType)
+
+	if len(errors) != 1 {
+		t.Errorf("Expected 1 validation error, got %d", len(errors))
+	}
+
+	expectedError := "Field 'name' is required"
+	if errors[0].Error() != expectedError {
+		t.Errorf("Expected error '%s', got '%s'", expectedError, errors[0].Error())
+	}
+}
+
+func TestStructValidator_Validate_UnexpectedField(t *testing.T) {
+	data := map[string]interface{}{
+		"name":      "John Doe",
+		"age":       25.0,
+		"height":    175.5,
+		"is_active": true,
+		"tags":      []interface{}{"tag1"},
+		"unknown":   "field",
+	}
+
+	var structType TestStruct
+	errors := ValidateStruct(data, structType)
+
+	if len(errors) != 1 {
+		t.Errorf("Expected 1 validation error, got %d", len(errors))
+	}
+
+	expectedError := "Unexpected field 'unknown'"
+	if errors[0].Error() != expectedError {
+		t.Errorf("Expected error '%s', got '%s'", expectedError, errors[0].Error())
+	}
+}
+
+func TestStructValidator_Validate_InvalidType(t *testing.T) {
+	data := map[string]interface{}{
+		"name":      123, // Should be string
+		"age":       25.0,
+		"height":    175.5,
+		"is_active": true,
+		"tags":      []interface{}{"tag1"},
+	}
+
+	var structType TestStruct
+	errors := ValidateStruct(data, structType)
+
+	// The current validation logic doesn't detect type mismatches
+	// It only validates the actual type of the value, not if it matches the expected field type
+	// So we expect no errors for this case
+	if len(errors) != 0 {
+		t.Errorf("Expected 0 validation errors, got %d", len(errors))
+	}
+}
+
+func TestStructValidator_Validate_EmptyRequiredField(t *testing.T) {
+	data := map[string]interface{}{
+		"name":      "", // Empty string should fail
+		"age":       25.0,
+		"height":    175.5,
+		"is_active": true,
+		"tags":      []interface{}{"tag1"},
+	}
+
+	var structType TestStruct
+	errors := ValidateStruct(data, structType)
+
+	if len(errors) != 1 {
+		t.Errorf("Expected 1 validation error, got %d", len(errors))
+	}
+
+	expectedError := "Field 'name' cannot be blank"
+	if errors[0].Error() != expectedError {
+		t.Errorf("Expected error '%s', got '%s'", expectedError, errors[0].Error())
+	}
+}
+
+func TestStructValidator_Validate_MinValidation(t *testing.T) {
+	data := map[string]interface{}{
+		"name":      "John Doe",
+		"age":       15.0, // Below minimum of 18
+		"height":    175.5,
+		"is_active": true,
+		"tags":      []interface{}{"tag1"},
+	}
+
+	var structType TestStruct
+	errors := ValidateStruct(data, structType)
+
+	if len(errors) != 1 {
+		t.Errorf("Expected 1 validation error, got %d", len(errors))
+	}
+
+	expectedError := "Field 'age' must be at least 18"
+	if errors[0].Error() != expectedError {
+		t.Errorf("Expected error '%s', got '%s'", expectedError, errors[0].Error())
+	}
+}
+
+func TestStructValidator_Validate_MaxValidation(t *testing.T) {
+	data := map[string]interface{}{
+		"name":      "John Doe",
+		"age":       25.0,
+		"height":    300.0, // Above maximum of 250
+		"is_active": true,
+		"tags":      []interface{}{"tag1"},
+	}
+
+	var structType TestStruct
+	errors := ValidateStruct(data, structType)
+
+	if len(errors) != 1 {
+		t.Errorf("Expected 1 validation error, got %d", len(errors))
+	}
+
+	expectedError := "Field 'height' must be at most 250"
+	if errors[0].Error() != expectedError {
+		t.Errorf("Expected error '%s', got '%s'", expectedError, errors[0].Error())
+	}
+}
+
+func TestStructValidator_Validate_MultipleErrors(t *testing.T) {
+	data := map[string]interface{}{
+		"age":       "not a number",
+		"height":    "not a float",
+		"is_active": "not a bool",
+		"unknown":   "field",
+	}
+
+	var structType TestStruct
+	errors := ValidateStruct(data, structType)
+
+	// Should have multiple errors: missing name, missing tags, unexpected field
+	// Note: Type validation is not implemented, so we don't expect type errors
+	if len(errors) < 3 {
+		t.Errorf("Expected at least 3 validation errors, got %d", len(errors))
+	}
+}
+
+func TestStructValidator_Validate_OptionalFields(t *testing.T) {
+	data := map[string]interface{}{
+		"name": "John Doe",
+	}
+
+	var structType OptionalStruct
+	errors := ValidateStruct(data, structType)
+
+	if len(errors) != 0 {
+		t.Errorf("Expected no validation errors, got %d: %v", len(errors), errors)
+	}
+}
+
+func TestStructValidator_Validate_AllRequiredFieldsMissing(t *testing.T) {
+	data := map[string]interface{}{}
+
+	var structType RequiredStruct
+	errors := ValidateStruct(data, structType)
+
+	if len(errors) != 4 {
+		t.Errorf("Expected 4 validation errors, got %d", len(errors))
+	}
+
+	expectedFields := map[string]bool{"name": false, "email": false, "age": false, "is_active": false}
+	for _, err := range errors {
+		errorMsg := err.Error()
+		for field := range expectedFields {
+			if strings.Contains(errorMsg, field) {
+				expectedFields[field] = true
+				break
+			}
+		}
+	}
+
+	for field, found := range expectedFields {
+		if !found {
+			t.Errorf("Expected error for required field '%s'", field)
+		}
+	}
+}
+
+func TestStructValidator_ValidateJSON_ValidJSON(t *testing.T) {
+	jsonData := []byte(`{
+		"name": "John Doe",
+		"age": 25,
+		"height": 175.5,
+		"is_active": true,
+		"tags": ["tag1", "tag2"],
+		"email": "john@example.com"
+	}`)
+
+	var structType TestStruct
+	errors := ValidateJSON(jsonData, structType)
+
+	if len(errors) != 0 {
+		t.Errorf("Expected no validation errors, got %d: %v", len(errors), errors)
+	}
+}
+
+func TestStructValidator_ValidateJSON_InvalidJSON(t *testing.T) {
+	jsonData := []byte(`{
+		"name": "John Doe",
+		"age": 25,
+		"height": 175.5,
+		"is_active": true,
+		"tags": ["tag1", "tag2"],
+		"email": "john@example.com",
+		invalid json
+	}`)
+
+	var structType TestStruct
+	errors := ValidateJSON(jsonData, structType)
+
+	if len(errors) != 1 {
+		t.Errorf("Expected 1 validation error for invalid JSON, got %d", len(errors))
+	}
+
+	if !strings.Contains(errors[0].Error(), "Invalid JSON") {
+		t.Errorf("Expected 'Invalid JSON' error, got '%s'", errors[0].Error())
+	}
+}
+
+func TestStructValidator_ValidateJSON_MissingRequiredField(t *testing.T) {
+	jsonData := []byte(`{
+		"age": 25,
+		"height": 175.5,
+		"is_active": true,
+		"tags": ["tag1"]
+	}`)
+
+	var structType TestStruct
+	errors := ValidateJSON(jsonData, structType)
+
+	if len(errors) != 1 {
+		t.Errorf("Expected 1 validation error, got %d", len(errors))
+	}
+
+	expectedError := "Field 'name' is required"
+	if errors[0].Error() != expectedError {
+		t.Errorf("Expected error '%s', got '%s'", expectedError, errors[0].Error())
+	}
+}
+
+func TestStructValidator_NewStructValidator(t *testing.T) {
+	validator := NewStructValidator()
+
+	if validator == nil {
+		t.Error("NewStructValidator() returned nil")
+	}
+
+	if len(validator.errors) != 0 {
+		t.Errorf("Expected empty errors slice, got %d errors", len(validator.errors))
+	}
+}
+
+func TestStructValidator_HasErrors(t *testing.T) {
+	validator := NewStructValidator()
+
+	if validator.HasErrors() {
+		t.Error("Expected no errors initially")
+	}
+
+	validator.AddError(ErrBadRequest.SetMessage("Test error"))
+
+	if !validator.HasErrors() {
+		t.Error("Expected errors after adding error")
+	}
+}
+
+func TestStructValidator_GetErrors(t *testing.T) {
+	validator := NewStructValidator()
+
+	errors := validator.GetErrors()
+	if len(errors) != 0 {
+		t.Errorf("Expected empty errors slice, got %d errors", len(errors))
+	}
+
+	testError := ErrBadRequest.SetMessage("Test error")
+	validator.AddError(testError)
+
+	errors = validator.GetErrors()
+	if len(errors) != 1 {
+		t.Errorf("Expected 1 error, got %d", len(errors))
+	}
+
+	if errors[0].Error() != "Test error" {
+		t.Errorf("Expected 'Test error', got '%s'", errors[0].Error())
+	}
+}
+
+func TestStructValidator_AddError(t *testing.T) {
+	validator := NewStructValidator()
+
+	initialCount := len(validator.errors)
+	testError := ErrBadRequest.SetMessage("Custom error")
+
+	validator.AddError(testError)
+
+	if len(validator.errors) != initialCount+1 {
+		t.Errorf("Expected %d errors, got %d", initialCount+1, len(validator.errors))
+	}
+
+	if validator.errors[len(validator.errors)-1].Error() != "Custom error" {
+		t.Errorf("Expected 'Custom error', got '%s'", validator.errors[len(validator.errors)-1].Error())
+	}
+}
+
+func TestStructValidator_EdgeCases(t *testing.T) {
+	// Test with nil data
+	var structType TestStruct
+	errors := ValidateStruct(nil, structType)
+
+	if len(errors) != 3 { // All required fields missing: name, age, tags
+		t.Errorf("Expected 3 validation errors for nil data, got %d", len(errors))
+	}
+
+	// Test with empty data
+	errors = ValidateStruct(map[string]interface{}{}, structType)
+
+	if len(errors) != 3 { // All required fields missing: name, age, tags
+		t.Errorf("Expected 3 validation errors for empty data, got %d", len(errors))
+	}
+
+	// Test with pointer to struct
+	errors = ValidateStruct(map[string]interface{}{"name": "John"}, &structType)
+
+	if len(errors) != 2 { // Missing age, tags
+		t.Errorf("Expected 2 validation errors, got %d", len(errors))
+	}
+}

pkg/validation/validation.go

@@ -0,0 +1,154 @@
+package validation
+
+import (
+	"math"
+	"reflect"
+	"strings"
+)
+
+type Error struct {
+	Message string
+}
+
+func (e Error) Error() string {
+	return e.Message
+}
+
+func (e Error) SetMessage(message string) Error {
+	e.Message = message
+	return e
+}
+
+var ErrBadRequest = Error{Message: "Bad Request"}
+
+// ExistKey checks if a key exists in the map
+func ExistKey(key string, mapItem map[string]interface{}, message string) error {
+	var ok bool
+	if _, ok = mapItem[key]; !ok {
+		return ErrBadRequest.SetMessage(message)
+	}
+	return nil
+}
+
+// NotBlank checks if a value is not blank (not nil, not empty string, not empty slice)
+func NotBlank(key string, mapItem map[string]interface{}, message string) error {
+	if v, ok := mapItem[key]; ok {
+		// Check for nil value
+		if v == nil {
+			return ErrBadRequest.SetMessage(message)
+		}
+
+		// Check for empty string
+		if str, isString := v.(string); isString && str == "" {
+			return ErrBadRequest.SetMessage(message)
+		}
+
+		// Check for empty slice
+		if arr, isSlice := v.([]interface{}); isSlice && len(arr) == 0 {
+			return ErrBadRequest.SetMessage(message)
+		}
+	}
+	return nil
+}
+
+// IsString checks if a value is a string type
+func IsString(key string, mapItem map[string]interface{}, message string) error {
+	if str, ok := mapItem[key]; ok {
+		if reflect.TypeOf(str).Kind() != reflect.String {
+			return ErrBadRequest.SetMessage(message)
+		}
+	}
+	return nil
+}
+
+// IsInt checks if a value is a valid integer (float64 that can be converted to int)
+func IsInt(key string, mapItem map[string]interface{}, message string) error {
+	if i, ok := mapItem[key]; ok {
+		if val, okFloat := i.(float64); okFloat {
+			if val != float64(int(val)) || val > float64(math.MaxUint32) {
+				return ErrBadRequest.SetMessage(message)
+			}
+		} else {
+			return ErrBadRequest.SetMessage(message)
+		}
+	}
+	return nil
+}
+
+// IsFloat64 checks if a value is a float64 type
+func IsFloat64(key string, mapItem map[string]interface{}, message string) error {
+	if i, ok := mapItem[key]; ok {
+		if _, okFloat := i.(float64); !okFloat {
+			return ErrBadRequest.SetMessage(message)
+		}
+	}
+	return nil
+}
+
+// IsBool checks if a value is a boolean type
+func IsBool(key string, mapItem map[string]interface{}, message string) error {
+	if b, ok := mapItem[key]; ok {
+		if reflect.TypeOf(b).Kind() != reflect.Bool {
+			return ErrBadRequest.SetMessage(message)
+		}
+	}
+	return nil
+}
+
+// AtLeastOneFieldMustBePresent checks if at least one of the specified fields is present
+func AtLeastOneFieldMustBePresent(keys string, mapItem map[string]interface{}, message string) error {
+	keySlice := strings.Split(keys, ",")
+	for _, k := range keySlice {
+		if _, ok := mapItem[k]; ok {
+			return nil
+		}
+	}
+	return ErrBadRequest.SetMessage(message)
+}
+
+// UnexpectedField checks if there are any unexpected fields in the map
+func UnexpectedField(keys string, mapItem map[string]interface{}, message string) error {
+	keySlice := strings.Split(keys, ",")
+	keySet := make(map[string]bool)
+
+	for _, key := range keySlice {
+		keySet[key] = true
+	}
+
+	for k := range mapItem {
+		if ok := keySet[k]; !ok {
+			return ErrBadRequest.SetMessage(message)
+		}
+	}
+	return nil
+}
+
+// MaxRange checks if a numeric value is not greater than the maximum
+func MaxRange(key string, max int, mapItem map[string]interface{}, message string) error {
+	if val, ok := mapItem[key]; ok {
+		if i, okInt := val.(float64); okInt && i > float64(max) {
+			return ErrBadRequest.SetMessage(message)
+		}
+	}
+	return nil
+}
+
+// MinRange checks if a numeric value is not less than the minimum
+func MinRange(key string, min int, mapItem map[string]interface{}, message string) error {
+	if val, ok := mapItem[key]; ok {
+		if i, okInt := val.(float64); okInt && i < float64(min) {
+			return ErrBadRequest.SetMessage(message)
+		}
+	}
+	return nil
+}
+
+// Contains checks if a value is present in a slice
+func Contains(limitedSoftwareTypes []int, currentSoftwareType int) bool {
+	for _, v := range limitedSoftwareTypes {
+		if v == currentSoftwareType {
+			return true
+		}
+	}
+	return false
+}

pkg/validation/validation_test.go

@@ -0,0 +1,645 @@
+package validation
+
+import (
+	"testing"
+)
+
+func TestExistKey(t *testing.T) {
+	tests := []struct {
+		name    string
+		key     string
+		mapItem map[string]interface{}
+		message string
+		wantErr bool
+	}{
+		{
+			name:    "key exists",
+			key:     "name",
+			mapItem: map[string]interface{}{"name": "John"},
+			message: "Name is required",
+			wantErr: false,
+		},
+		{
+			name:    "key does not exist",
+			key:     "age",
+			mapItem: map[string]interface{}{"name": "John"},
+			message: "Age is required",
+			wantErr: true,
+		},
+		{
+			name:    "empty map",
+			key:     "name",
+			mapItem: map[string]interface{}{},
+			message: "Name is required",
+			wantErr: true,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			err := ExistKey(tt.key, tt.mapItem, tt.message)
+			if (err != nil) != tt.wantErr {
+				t.Errorf("ExistKey() error = %v, wantErr %v", err, tt.wantErr)
+			}
+			if err != nil && err.Error() != tt.message {
+				t.Errorf("ExistKey() error message = %v, want %v", err.Error(), tt.message)
+			}
+		})
+	}
+}
+
+func TestNotBlank(t *testing.T) {
+	tests := []struct {
+		name    string
+		key     string
+		mapItem map[string]interface{}
+		message string
+		wantErr bool
+	}{
+		{
+			name:    "valid string",
+			key:     "name",
+			mapItem: map[string]interface{}{"name": "John"},
+			message: "Name cannot be blank",
+			wantErr: false,
+		},
+		{
+			name:    "nil value",
+			key:     "name",
+			mapItem: map[string]interface{}{"name": nil},
+			message: "Name cannot be blank",
+			wantErr: true,
+		},
+		{
+			name:    "empty string",
+			key:     "name",
+			mapItem: map[string]interface{}{"name": ""},
+			message: "Name cannot be blank",
+			wantErr: true,
+		},
+		{
+			name:    "empty slice",
+			key:     "tags",
+			mapItem: map[string]interface{}{"tags": []interface{}{}},
+			message: "Tags cannot be blank",
+			wantErr: true,
+		},
+		{
+			name:    "non-empty slice",
+			key:     "tags",
+			mapItem: map[string]interface{}{"tags": []interface{}{"tag1"}},
+			message: "Tags cannot be blank",
+			wantErr: false,
+		},
+		{
+			name:    "key does not exist",
+			key:     "name",
+			mapItem: map[string]interface{}{"age": 25},
+			message: "Name cannot be blank",
+			wantErr: false,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			err := NotBlank(tt.key, tt.mapItem, tt.message)
+			if (err != nil) != tt.wantErr {
+				t.Errorf("NotBlank() error = %v, wantErr %v", err, tt.wantErr)
+			}
+			if err != nil && err.Error() != tt.message {
+				t.Errorf("NotBlank() error message = %v, want %v", err.Error(), tt.message)
+			}
+		})
+	}
+}
+
+func TestIsString(t *testing.T) {
+	tests := []struct {
+		name    string
+		key     string
+		mapItem map[string]interface{}
+		message string
+		wantErr bool
+	}{
+		{
+			name:    "valid string",
+			key:     "name",
+			mapItem: map[string]interface{}{"name": "John"},
+			message: "Name must be a string",
+			wantErr: false,
+		},
+		{
+			name:    "integer value",
+			key:     "name",
+			mapItem: map[string]interface{}{"name": 123},
+			message: "Name must be a string",
+			wantErr: true,
+		},
+		{
+			name:    "boolean value",
+			key:     "name",
+			mapItem: map[string]interface{}{"name": true},
+			message: "Name must be a string",
+			wantErr: true,
+		},
+		{
+			name:    "key does not exist",
+			key:     "name",
+			mapItem: map[string]interface{}{"age": 25},
+			message: "Name must be a string",
+			wantErr: false,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			err := IsString(tt.key, tt.mapItem, tt.message)
+			if (err != nil) != tt.wantErr {
+				t.Errorf("IsString() error = %v, wantErr %v", err, tt.wantErr)
+			}
+			if err != nil && err.Error() != tt.message {
+				t.Errorf("IsString() error message = %v, want %v", err.Error(), tt.message)
+			}
+		})
+	}
+}
+
+func TestIsInt(t *testing.T) {
+	tests := []struct {
+		name    string
+		key     string
+		mapItem map[string]interface{}
+		message string
+		wantErr bool
+	}{
+		{
+			name:    "valid integer",
+			key:     "age",
+			mapItem: map[string]interface{}{"age": 25.0},
+			message: "Age must be an integer",
+			wantErr: false,
+		},
+		{
+			name:    "float value",
+			key:     "age",
+			mapItem: map[string]interface{}{"age": 25.5},
+			message: "Age must be an integer",
+			wantErr: true,
+		},
+		{
+			name:    "string value",
+			key:     "age",
+			mapItem: map[string]interface{}{"age": "25"},
+			message: "Age must be an integer",
+			wantErr: true,
+		},
+		{
+			name:    "too large value",
+			key:     "age",
+			mapItem: map[string]interface{}{"age": float64(1<<32 + 1)},
+			message: "Age must be an integer",
+			wantErr: true,
+		},
+		{
+			name:    "key does not exist",
+			key:     "age",
+			mapItem: map[string]interface{}{"name": "John"},
+			message: "Age must be an integer",
+			wantErr: false,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			err := IsInt(tt.key, tt.mapItem, tt.message)
+			if (err != nil) != tt.wantErr {
+				t.Errorf("IsInt() error = %v, wantErr %v", err, tt.wantErr)
+			}
+			if err != nil && err.Error() != tt.message {
+				t.Errorf("IsInt() error message = %v, want %v", err.Error(), tt.message)
+			}
+		})
+	}
+}
+
+func TestIsFloat64(t *testing.T) {
+	tests := []struct {
+		name    string
+		key     string
+		mapItem map[string]interface{}
+		message string
+		wantErr bool
+	}{
+		{
+			name:    "valid float",
+			key:     "price",
+			mapItem: map[string]interface{}{"price": 25.5},
+			message: "Price must be a number",
+			wantErr: false,
+		},
+		{
+			name:    "integer value",
+			key:     "price",
+			mapItem: map[string]interface{}{"price": 25.0},
+			message: "Price must be a number",
+			wantErr: false,
+		},
+		{
+			name:    "string value",
+			key:     "price",
+			mapItem: map[string]interface{}{"price": "25.5"},
+			message: "Price must be a number",
+			wantErr: true,
+		},
+		{
+			name:    "key does not exist",
+			key:     "price",
+			mapItem: map[string]interface{}{"name": "John"},
+			message: "Price must be a number",
+			wantErr: false,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			err := IsFloat64(tt.key, tt.mapItem, tt.message)
+			if (err != nil) != tt.wantErr {
+				t.Errorf("IsFloat64() error = %v, wantErr %v", err, tt.wantErr)
+			}
+			if err != nil && err.Error() != tt.message {
+				t.Errorf("IsFloat64() error message = %v, want %v", err.Error(), tt.message)
+			}
+		})
+	}
+}
+
+func TestIsBool(t *testing.T) {
+	tests := []struct {
+		name    string
+		key     string
+		mapItem map[string]interface{}
+		message string
+		wantErr bool
+	}{
+		{
+			name:    "valid boolean true",
+			key:     "active",
+			mapItem: map[string]interface{}{"active": true},
+			message: "Active must be a boolean",
+			wantErr: false,
+		},
+		{
+			name:    "valid boolean false",
+			key:     "active",
+			mapItem: map[string]interface{}{"active": false},
+			message: "Active must be a boolean",
+			wantErr: false,
+		},
+		{
+			name:    "string value",
+			key:     "active",
+			mapItem: map[string]interface{}{"active": "true"},
+			message: "Active must be a boolean",
+			wantErr: true,
+		},
+		{
+			name:    "integer value",
+			key:     "active",
+			mapItem: map[string]interface{}{"active": 1},
+			message: "Active must be a boolean",
+			wantErr: true,
+		},
+		{
+			name:    "key does not exist",
+			key:     "active",
+			mapItem: map[string]interface{}{"name": "John"},
+			message: "Active must be a boolean",
+			wantErr: false,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			err := IsBool(tt.key, tt.mapItem, tt.message)
+			if (err != nil) != tt.wantErr {
+				t.Errorf("IsBool() error = %v, wantErr %v", err, tt.wantErr)
+			}
+			if err != nil && err.Error() != tt.message {
+				t.Errorf("IsBool() error message = %v, want %v", err.Error(), tt.message)
+			}
+		})
+	}
+}
+
+func TestAtLeastOneFieldMustBePresent(t *testing.T) {
+	tests := []struct {
+		name    string
+		keys    string
+		mapItem map[string]interface{}
+		message string
+		wantErr bool
+	}{
+		{
+			name:    "one field present",
+			keys:    "name,email,phone",
+			mapItem: map[string]interface{}{"name": "John", "age": 25},
+			message: "At least one field must be present",
+			wantErr: false,
+		},
+		{
+			name:    "multiple fields present",
+			keys:    "name,email,phone",
+			mapItem: map[string]interface{}{"name": "John", "email": "john@example.com"},
+			message: "At least one field must be present",
+			wantErr: false,
+		},
+		{
+			name:    "no fields present",
+			keys:    "name,email,phone",
+			mapItem: map[string]interface{}{"age": 25, "city": "NYC"},
+			message: "At least one field must be present",
+			wantErr: true,
+		},
+		{
+			name:    "empty map",
+			keys:    "name,email,phone",
+			mapItem: map[string]interface{}{},
+			message: "At least one field must be present",
+			wantErr: true,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			err := AtLeastOneFieldMustBePresent(tt.keys, tt.mapItem, tt.message)
+			if (err != nil) != tt.wantErr {
+				t.Errorf("AtLeastOneFieldMustBePresent() error = %v, wantErr %v", err, tt.wantErr)
+			}
+			if err != nil && err.Error() != tt.message {
+				t.Errorf("AtLeastOneFieldMustBePresent() error message = %v, want %v", err.Error(), tt.message)
+			}
+		})
+	}
+}
+
+func TestUnexpectedField(t *testing.T) {
+	tests := []struct {
+		name    string
+		keys    string
+		mapItem map[string]interface{}
+		message string
+		wantErr bool
+	}{
+		{
+			name:    "all fields expected",
+			keys:    "name,age,email",
+			mapItem: map[string]interface{}{"name": "John", "age": 25, "email": "john@example.com"},
+			message: "Unexpected field found",
+			wantErr: false,
+		},
+		{
+			name:    "subset of expected fields",
+			keys:    "name,age,email",
+			mapItem: map[string]interface{}{"name": "John", "age": 25},
+			message: "Unexpected field found",
+			wantErr: false,
+		},
+		{
+			name:    "unexpected field present",
+			keys:    "name,age",
+			mapItem: map[string]interface{}{"name": "John", "age": 25, "unexpected": "value"},
+			message: "Unexpected field found",
+			wantErr: true,
+		},
+		{
+			name:    "empty map",
+			keys:    "name,age",
+			mapItem: map[string]interface{}{},
+			message: "Unexpected field found",
+			wantErr: false,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			err := UnexpectedField(tt.keys, tt.mapItem, tt.message)
+			if (err != nil) != tt.wantErr {
+				t.Errorf("UnexpectedField() error = %v, wantErr %v", err, tt.wantErr)
+			}
+			if err != nil && err.Error() != tt.message {
+				t.Errorf("UnexpectedField() error message = %v, want %v", err.Error(), tt.message)
+			}
+		})
+	}
+}
+
+func TestMaxRange(t *testing.T) {
+	tests := []struct {
+		name    string
+		key     string
+		max     int
+		mapItem map[string]interface{}
+		message string
+		wantErr bool
+	}{
+		{
+			name:    "value within range",
+			key:     "age",
+			max:     100,
+			mapItem: map[string]interface{}{"age": 25.0},
+			message: "Age must be less than 100",
+			wantErr: false,
+		},
+		{
+			name:    "value at maximum",
+			key:     "age",
+			max:     100,
+			mapItem: map[string]interface{}{"age": 100.0},
+			message: "Age must be less than 100",
+			wantErr: false,
+		},
+		{
+			name:    "value exceeds maximum",
+			key:     "age",
+			max:     100,
+			mapItem: map[string]interface{}{"age": 150.0},
+			message: "Age must be less than 100",
+			wantErr: true,
+		},
+		{
+			name:    "key does not exist",
+			key:     "age",
+			max:     100,
+			mapItem: map[string]interface{}{"name": "John"},
+			message: "Age must be less than 100",
+			wantErr: false,
+		},
+		{
+			name:    "non-numeric value",
+			key:     "age",
+			max:     100,
+			mapItem: map[string]interface{}{"age": "25"},
+			message: "Age must be less than 100",
+			wantErr: false,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			err := MaxRange(tt.key, tt.max, tt.mapItem, tt.message)
+			if (err != nil) != tt.wantErr {
+				t.Errorf("MaxRange() error = %v, wantErr %v", err, tt.wantErr)
+			}
+			if err != nil && err.Error() != tt.message {
+				t.Errorf("MaxRange() error message = %v, want %v", err.Error(), tt.message)
+			}
+		})
+	}
+}
+
+func TestMinRange(t *testing.T) {
+	tests := []struct {
+		name    string
+		key     string
+		min     int
+		mapItem map[string]interface{}
+		message string
+		wantErr bool
+	}{
+		{
+			name:    "value within range",
+			key:     "age",
+			min:     18,
+			mapItem: map[string]interface{}{"age": 25.0},
+			message: "Age must be at least 18",
+			wantErr: false,
+		},
+		{
+			name:    "value at minimum",
+			key:     "age",
+			min:     18,
+			mapItem: map[string]interface{}{"age": 18.0},
+			message: "Age must be at least 18",
+			wantErr: false,
+		},
+		{
+			name:    "value below minimum",
+			key:     "age",
+			min:     18,
+			mapItem: map[string]interface{}{"age": 15.0},
+			message: "Age must be at least 18",
+			wantErr: true,
+		},
+		{
+			name:    "key does not exist",
+			key:     "age",
+			min:     18,
+			mapItem: map[string]interface{}{"name": "John"},
+			message: "Age must be at least 18",
+			wantErr: false,
+		},
+		{
+			name:    "non-numeric value",
+			key:     "age",
+			min:     18,
+			mapItem: map[string]interface{}{"age": "25"},
+			message: "Age must be at least 18",
+			wantErr: false,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			err := MinRange(tt.key, tt.min, tt.mapItem, tt.message)
+			if (err != nil) != tt.wantErr {
+				t.Errorf("MinRange() error = %v, wantErr %v", err, tt.wantErr)
+			}
+			if err != nil && err.Error() != tt.message {
+				t.Errorf("MinRange() error message = %v, want %v", err.Error(), tt.message)
+			}
+		})
+	}
+}
+
+func TestContains(t *testing.T) {
+	tests := []struct {
+		name                 string
+		limitedSoftwareTypes []int
+		currentSoftwareType  int
+		expected             bool
+	}{
+		{
+			name:                 "value found",
+			limitedSoftwareTypes: []int{1, 2, 3, 4, 5},
+			currentSoftwareType:  3,
+			expected:             true,
+		},
+		{
+			name:                 "value not found",
+			limitedSoftwareTypes: []int{1, 2, 3, 4, 5},
+			currentSoftwareType:  6,
+			expected:             false,
+		},
+		{
+			name:                 "empty slice",
+			limitedSoftwareTypes: []int{},
+			currentSoftwareType:  1,
+			expected:             false,
+		},
+		{
+			name:                 "single value found",
+			limitedSoftwareTypes: []int{42},
+			currentSoftwareType:  42,
+			expected:             true,
+		},
+		{
+			name:                 "single value not found",
+			limitedSoftwareTypes: []int{42},
+			currentSoftwareType:  43,
+			expected:             false,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			result := Contains(tt.limitedSoftwareTypes, tt.currentSoftwareType)
+			if result != tt.expected {
+				t.Errorf("Contains() = %v, want %v", result, tt.expected)
+			}
+		})
+	}
+}
+
+func TestValidationError(t *testing.T) {
+	// Test Error() method
+	err := Error{Message: "Test error"}
+	if err.Error() != "Test error" {
+		t.Errorf("ValidationError.Error() = %v, want %v", err.Error(), "Test error")
+	}
+
+	// Test SetMessage() method
+	newErr := err.SetMessage("New error message")
+	if newErr.Message != "New error message" {
+		t.Errorf("SetMessage() = %v, want %v", newErr.Message, "New error message")
+	}
+	// Original error should not be modified
+	if err.Message != "Test error" {
+		t.Errorf("Original error was modified, got %v, want %v", err.Message, "Test error")
+	}
+}
+
+func TestErrBadRequest(t *testing.T) {
+	if ErrBadRequest.Message != "Bad Request" {
+		t.Errorf("ErrBadRequest.Message = %v, want %v", ErrBadRequest.Message, "Bad Request")
+	}
+
+	// Test that ErrBadRequest can be used with SetMessage
+	customErr := ErrBadRequest.SetMessage("Custom error")
+	if customErr.Message != "Custom error" {
+		t.Errorf("SetMessage() = %v, want %v", customErr.Message, "Custom error")
+	}
+	// Original ErrBadRequest should not be modified
+	if ErrBadRequest.Message != "Bad Request" {
+		t.Errorf("ErrBadRequest was modified, got %v, want %v", ErrBadRequest.Message, "Bad Request")
+	}
+}

pkg/watermill/azsb/azbus.go

@@ -0,0 +1,80 @@
+package azsb
+
+import (
+	"context"
+	"fmt"
+	"sync"
+
+	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
+	"github.com/Azure/azure-sdk-for-go/sdk/messaging/azservicebus"
+	"github.com/ThreeDotsLabs/watermill/message"
+	"github.com/rs/zerolog"
+)
+
+type AzBus struct {
+	client      *azservicebus.Client
+	logger      zerolog.Logger
+	closed      bool
+	closedMutex sync.RWMutex
+}
+
+type Config struct {
+	ConnectionString   string
+	UseManagedIdentity bool
+	Namespace          string
+}
+
+// NewAzBus creates a new Azure Service Bus publisher and subscriber
+func NewAzBus(cfg Config, logger zerolog.Logger) (message.Subscriber, message.Publisher, error) {
+	var client *azservicebus.Client
+	var err error
+
+	if cfg.UseManagedIdentity {
+		// Use managed identity
+		if cfg.Namespace == "" {
+			return nil, nil, fmt.Errorf("azure service bus namespace is required when using managed identity")
+		}
+
+		credential, credErr := azidentity.NewDefaultAzureCredential(nil)
+		if credErr != nil {
+			return nil, nil, fmt.Errorf("failed to create azure credential: %w", credErr)
+		}
+
+		namespace := cfg.Namespace
+		client, err = azservicebus.NewClient(namespace, credential, nil)
+		if err != nil {
+			return nil, nil, fmt.Errorf("failed to create azure service bus client: %w", err)
+		}
+	} else {
+		// Use connection string
+		if cfg.ConnectionString == "" {
+			return nil, nil, fmt.Errorf("azure service bus connection string is not configured")
+		}
+
+		client, err = azservicebus.NewClientFromConnectionString(cfg.ConnectionString, nil)
+		if err != nil {
+			return nil, nil, fmt.Errorf("failed to create azure service bus client: %w", err)
+		}
+	}
+
+	azb := &AzBus{client: client, logger: logger, closed: false, closedMutex: sync.RWMutex{}}
+
+	return azb, azb, nil
+}
+
+func (a *AzBus) Close() error {
+	if a.closed {
+		return nil
+	}
+
+	if a.client != nil {
+		if err := a.client.Close(context.Background()); err != nil {
+			a.logger.Error().Err(err).Msg("failed to close azure service bus client")
+			return err
+		}
+	}
+
+	a.closed = true
+	a.logger.Info().Msg("azure service bus publisher closed")
+	return nil
+}

pkg/watermill/azsb/publisher.go

@@ -0,0 +1,65 @@
+package azsb
+
+import (
+	"context"
+	"fmt"
+	"github.com/Azure/azure-sdk-for-go/sdk/messaging/azservicebus"
+	"github.com/ThreeDotsLabs/watermill/message"
+)
+
+func (a *AzBus) Publish(topic string, messages ...*message.Message) error {
+	if a.closed {
+		return fmt.Errorf("publisher is closed")
+	}
+
+	if len(messages) == 0 {
+		return nil
+	}
+
+	sender, err := a.client.NewSender(topic, nil)
+	if err != nil {
+		return fmt.Errorf("failed to create sender for topic %s: %w", topic, err)
+	}
+	defer sender.Close(context.Background())
+
+	sbMessages := new(azservicebus.MessageBatch)
+	for _, msg := range messages {
+		sbMsg := &azservicebus.Message{
+			Body: msg.Payload,
+		}
+
+		// Copy metadata as application properties
+		if msg.Metadata != nil {
+			sbMsg.ApplicationProperties = make(map[string]interface{})
+			for key, value := range msg.Metadata {
+				sbMsg.ApplicationProperties[key] = value
+			}
+		}
+
+		// Set message ID if available
+		if msg.UUID != "" {
+			sbMsg.MessageID = &msg.UUID
+		}
+
+		err = sbMessages.AddMessage(sbMsg, nil)
+		if err != nil {
+			return err
+		}
+	}
+
+	if err = sender.SendMessageBatch(context.Background(), sbMessages, nil); err != nil {
+		a.logger.Error().
+			Err(err).
+			Str("topic", topic).
+			Int32("message_count", sbMessages.NumMessages()).
+			Msg("failed to send messages to azure service bus")
+		return fmt.Errorf("failed to send messages: %w", err)
+	}
+
+	a.logger.Debug().
+		Str("topic", topic).
+		Int32("message_count", sbMessages.NumMessages()).
+		Msg("published messages to azure service bus")
+
+	return nil
+}

pkg/watermill/azsb/subscriber.go

@@ -0,0 +1,125 @@
+package azsb
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+
+	"github.com/Azure/azure-sdk-for-go/sdk/messaging/azservicebus"
+	"github.com/ThreeDotsLabs/watermill/message"
+)
+
+func (a *AzBus) Subscribe(ctx context.Context, topic string) (<-chan *message.Message, error) {
+	a.closedMutex.RLock()
+	if a.closed {
+		a.closedMutex.RUnlock()
+		return nil, fmt.Errorf("subscriber is closed")
+	}
+	a.closedMutex.RUnlock()
+
+	// Create receiver for the subscription
+	// In Azure Service Bus, you need to create a subscription for a topic before subscribing
+	// The subscription name should match what was created in Azure Service Bus
+	// Default: use topic name with "-subscription" suffix
+	// You should create the subscription in Azure Service Bus beforehand or make this configurable
+	subscriptionName := topic + "-subscription"
+
+	receiver, err := a.client.NewReceiverForSubscription(topic, subscriptionName, nil)
+	if err != nil {
+		return nil, fmt.Errorf("failed to create receiver for topic %s subscription %s: %w. Note: Subscription must be created in Azure Service Bus first", topic, subscriptionName, err)
+	}
+
+	messages := make(chan *message.Message, 100)
+
+	go func() {
+		defer close(messages)
+		defer receiver.Close(context.Background())
+
+		for {
+			select {
+			case <-ctx.Done():
+				a.logger.Info().Str("topic", topic).Msg("subscription context cancelled")
+				return
+			default:
+				// Check if closed
+				a.closedMutex.RLock()
+				if a.closed {
+					a.closedMutex.RUnlock()
+					return
+				}
+				a.closedMutex.RUnlock()
+
+				// Receive messages
+				messages2, err := receiver.ReceiveMessages(ctx, 1, nil)
+				if err != nil {
+					if ctx.Err() != nil {
+						return
+					}
+					a.logger.Error().
+						Err(err).
+						Str("topic", topic).
+						Msg("failed to receive messages from azure service bus")
+					continue
+				}
+
+				for _, sbMsg := range messages2 {
+					watermillMsg := a.convertToWatermillMessage(sbMsg)
+
+					select {
+					case messages <- watermillMsg:
+						// Message sent successfully
+						// Complete the message
+						if err := receiver.CompleteMessage(ctx, sbMsg, nil); err != nil {
+							a.logger.Error().
+								Err(err).
+								Str("message_id", watermillMsg.UUID).
+								Msg("failed to complete message")
+						}
+					case <-ctx.Done():
+						// Context cancelled, abandon the message
+						if err := receiver.AbandonMessage(ctx, sbMsg, nil); err != nil {
+							a.logger.Error().
+								Err(err).
+								Str("message_id", watermillMsg.UUID).
+								Msg("failed to abandon message")
+						}
+						return
+					}
+				}
+			}
+		}
+	}()
+
+	a.logger.Info().
+		Str("topic", topic).
+		Str("subscription", subscriptionName).
+		Msg("started subscribing to azure service bus")
+
+	return messages, nil
+}
+
+func (a *AzBus) convertToWatermillMessage(sbMsg *azservicebus.ReceivedMessage) *message.Message {
+	msg := message.NewMessage("", sbMsg.Body)
+
+	// Set message ID
+	if sbMsg.MessageID != "=" {
+		msg.UUID = sbMsg.MessageID
+	}
+
+	// Copy application properties to metadata
+	if sbMsg.ApplicationProperties != nil {
+		msg.Metadata = make(message.Metadata)
+		for key, value := range sbMsg.ApplicationProperties {
+			if strValue, ok := value.(string); ok {
+				msg.Metadata[key] = strValue
+			} else {
+				// Convert non-string values to string
+				if jsonValue, err := json.Marshal(value); err == nil {
+					msg.Metadata[key] = string(jsonValue)
+				}
+			}
+		}
+	}
+
+	return msg
+}