feat: increase database module (#86)

* feat: increase database module

* feat: isodate and isotime tests

development-environment/database/clear-database.sql

@@ -1,3 +1,3 @@
 delete from users;
 delete from profiles;
-delete from dog;
+delete from contacts;

development-environment/database/schema.sql

@@ -11,9 +11,8 @@ CREATE TABLE IF NOT EXISTS users (
     CONSTRAINT fk_users_profiles FOREIGN KEY (profile_id) REFERENCES profiles (id)
 );
 
-CREATE TABLE IF NOT EXISTS dog
-(
-    id              SERIAL PRIMARY KEY,
-    name            TEXT NOT NULL,
-    characteristics TEXT[]
-);
+CREATE TABLE IF NOT EXISTS contacts (
+    id          SERIAL PRIMARY KEY,
+    name        TEXT NOT NULL,
+    email       TEXT UNIQUE
+);

pkg/base/transaction/mock_transaction.go

@@ -2,15 +2,23 @@ package transaction
 
 import "context"
 
-// mockSqlTransaction struct with implements Transaction for tests purpose
+// mockSqlTransaction implements a transaction.Transaction
 type mockSqlTransaction struct {
 }
 
-// NewMockTransaction create a mock transaction for tests purpose
+// NewMockTransaction returns a new mockSqlTransaction.
+//
+// No parameters.
+// Returns a Transaction.
 func NewMockTransaction() Transaction {
 	return mockSqlTransaction{}
 }
 
-func (m mockSqlTransaction) ExecTx(ctx context.Context, fn func(ctx context.Context) error) error {
+// Execute executes a mockSqlTransaction.
+//
+// ctx: The context for the transaction.
+// fn: The function to be executed.
+// Returns an error.
+func (m mockSqlTransaction) Execute(ctx context.Context, fn func(ctx context.Context) error) error {
 	return fn(ctx)
 }

pkg/base/transaction/mock_transaction_test.go

@@ -4,16 +4,17 @@ import (
 	"context"
 	"errors"
 	"fmt"
-	"github.com/stretchr/testify/assert"
 	"testing"
+
+	"github.com/stretchr/testify/assert"
 )
 
 func TestMockTransaction(t *testing.T) {
 	t.Run("execute no error", func(t *testing.T) {
 		f := func(ctx context.Context) error { return nil }
 		m := NewMockTransaction()
 
-		assert.NoError(t, m.ExecTx(context.Background(), f))
+		assert.NoError(t, m.Execute(context.Background(), f))
 	})
 
 	t.Run("execute with error", func(t *testing.T) {
@@ -23,6 +24,6 @@ func TestMockTransaction(t *testing.T) {
 		}
 		m := NewMockTransaction()
 
-		assert.ErrorIs(t, m.ExecTx(context.Background(), f), expectedErr)
+		assert.ErrorIs(t, m.Execute(context.Background(), f), expectedErr)
 	})
 }

pkg/base/transaction/transaction.go

@@ -4,6 +4,7 @@ import (
 	"context"
 )
 
+// Transaction defines the interface for a transaction
 type Transaction interface {
-	ExecTx(context.Context, func(ctx context.Context) error) error
+	Execute(context.Context, func(ctx context.Context) error) error
 }

pkg/base/types/iso_date.go

@@ -9,17 +9,54 @@ import (
 // IsoDate struct
 type IsoDate time.Time
 
-// Value converts iso date to sql driver value
+// ParseIsoDate converts string to iso date.
+//
+// It takes a string value as input.
+// Returns IsoDate and an error.
+func ParseIsoDate(value string) (IsoDate, error) {
+	parsedDate, err := time.Parse(time.DateOnly, value)
+	if err != nil {
+		return IsoDate{}, err
+	}
+
+	return IsoDate(parsedDate), nil
+}
+
+// Value converts iso date to sql driver value.
+//
+// Returns driver.Value and an error.
 func (t IsoDate) Value() (driver.Value, error) {
 	return time.Time(t), nil
 }
 
-// MarshalJSON converts iso date to json string format
+// String returns the iso date formatted using the format string.
+//
+// No parameters.
+// Returns a string.
+func (t IsoDate) String() string {
+	return time.Time(t).Format(time.DateOnly)
+}
+
+// GoString returns the iso date in Go source code format string.
+//
+// No parameters.
+// Returns a string.
+func (t IsoDate) GoString() string {
+	return time.Time(t).GoString()
+}
+
+// MarshalJSON converts iso date to json string format.
+//
+// No parameters.
+// Returns a byte slice and an error.
 func (t IsoDate) MarshalJSON() ([]byte, error) {
 	return json.Marshal(time.Time(t).Format(time.DateOnly))
 }
 
-// UnmarshalJSON converts json string to iso date
+// UnmarshalJSON converts json string to iso date.
+//
+// It takes a byte slice as the input data.
+// Returns an error.
 func (t *IsoDate) UnmarshalJSON(data []byte) error {
 	var ptr *string
 	if err := json.Unmarshal(data, &ptr); err != nil {

pkg/base/types/iso_date_test.go

@@ -8,6 +8,42 @@ import (
 )
 
 func TestIsoDate(t *testing.T) {
+	t.Run("Should get parsed iso date", func(t *testing.T) {
+		expected := IsoDate(time.Date(2022, time.January, 30, 0, 0, 0, 0, time.UTC))
+
+		result, err := ParseIsoDate("2022-01-30")
+
+		assert.Nil(t, err)
+		assert.NotNil(t, result)
+		assert.Equal(t, expected, result)
+	})
+
+	t.Run("Should return error when parse with a invalid string", func(t *testing.T) {
+		result, err := ParseIsoDate("invalid")
+
+		assert.NotNil(t, err)
+		assert.NotNil(t, result)
+		assert.Equal(t, IsoDate(time.Date(1, time.January, 1, 0, 0, 0, 0, time.UTC)), result)
+	})
+
+	t.Run("Should get string iso date", func(t *testing.T) {
+		expected := "2022-01-30"
+
+		result := IsoDate(time.Date(2022, time.January, 30, 0, 0, 0, 0, time.UTC)).String()
+
+		assert.NotNil(t, result)
+		assert.Equal(t, expected, result)
+	})
+
+	t.Run("Should get go string iso date", func(t *testing.T) {
+		expected := "time.Date(2022, time.January, 30, 0, 0, 0, 0, time.UTC)"
+
+		result := IsoDate(time.Date(2022, time.January, 30, 0, 0, 0, 0, time.UTC)).GoString()
+
+		assert.NotNil(t, result)
+		assert.Equal(t, expected, result)
+	})
+
 	t.Run("Should get value with a valid value", func(t *testing.T) {
 		expected := time.Date(2022, time.January, 1, 0, 0, 0, 0, time.UTC)
 

pkg/base/types/iso_time.go

@@ -9,17 +9,54 @@ import (
 // IsoTime struct
 type IsoTime time.Time
 
-// Value converts iso time to sql driver value
+// ParseIsoTime converts string to iso time.
+//
+// It takes a string value as input.
+// Returns IsoTime and an error.
+func ParseIsoTime(value string) (IsoTime, error) {
+	parsedTime, err := time.Parse(time.TimeOnly, value)
+	if err != nil {
+		return IsoTime{}, err
+	}
+
+	return IsoTime(parsedTime), nil
+}
+
+// Value converts iso time to sql driver value.
+//
+// Returns driver.Value and an error.
 func (t IsoTime) Value() (driver.Value, error) {
 	return time.Time(t), nil
 }
 
-// MarshalJSON converts iso time to json string format
+// String returns the iso time formatted using the format string
+//
+// No parameters.
+// Returns a string.
+func (t IsoTime) String() string {
+	return time.Time(t).Format(time.TimeOnly)
+}
+
+// GoString returns the iso time in Go source code format string.
+//
+// No parameters.
+// Returns a string.
+func (t IsoTime) GoString() string {
+	return time.Time(t).GoString()
+}
+
+// MarshalJSON converts iso time to json string format.
+//
+// No parameters.
+// Returns a byte slice and an error.
 func (t IsoTime) MarshalJSON() ([]byte, error) {
 	return json.Marshal(time.Time(t).Format(time.TimeOnly))
 }
 
 // UnmarshalJSON converts json string to iso time
+//
+// It takes a byte slice as the input data.
+// Returns an error.
 func (t *IsoTime) UnmarshalJSON(data []byte) error {
 	var ptr *string
 	if err := json.Unmarshal(data, &ptr); err != nil {

pkg/base/types/iso_time_test.go

@@ -8,6 +8,42 @@ import (
 )
 
 func TestIsoTime(t *testing.T) {
+	t.Run("Should get parsed iso time", func(t *testing.T) {
+		expected := IsoTime(time.Date(0, time.January, 1, 10, 20, 30, 0, time.UTC))
+
+		result, err := ParseIsoTime("10:20:30")
+
+		assert.Nil(t, err)
+		assert.NotNil(t, result)
+		assert.Equal(t, expected, result)
+	})
+
+	t.Run("Should return error when parse with a invalid string", func(t *testing.T) {
+		result, err := ParseIsoTime("invalid")
+
+		assert.NotNil(t, err)
+		assert.NotNil(t, result)
+		assert.Equal(t, IsoTime(time.Date(1, time.January, 1, 0, 0, 0, 0, time.UTC)), result)
+	})
+
+	t.Run("Should get string iso time", func(t *testing.T) {
+		expected := "10:20:30"
+
+		result := IsoTime(time.Date(0, time.January, 1, 10, 20, 30, 0, time.UTC)).String()
+
+		assert.NotNil(t, result)
+		assert.Equal(t, expected, result)
+	})
+
+	t.Run("Should get go string iso time", func(t *testing.T) {
+		expected := "time.Date(0, time.January, 1, 10, 20, 30, 0, time.UTC)"
+
+		result := IsoTime(time.Date(0, time.January, 1, 10, 20, 30, 0, time.UTC)).GoString()
+
+		assert.NotNil(t, result)
+		assert.Equal(t, expected, result)
+	})
+
 	t.Run("Should get value with a valid value", func(t *testing.T) {
 		expected := time.Date(1, time.January, 1, 10, 20, 30, 0, time.UTC)
 

pkg/base/validator/validator.go

@@ -1,6 +1,7 @@
 package validator
 
 import (
+	"github.com/colibri-project-io/colibri-sdk-go/pkg/base/types"
 	form "github.com/go-playground/form/v4"
 	playValidator "github.com/go-playground/validator/v10"
 	"github.com/google/uuid"
@@ -13,25 +14,63 @@ type Validator struct {
 
 var instance *Validator
 
+// Initialize initializes the Validator instance with playValidator and formDecoder, then registers custom types.
+//
+// No parameters.
+// No return values.
 func Initialize() {
 	instance = &Validator{
 		validator:   playValidator.New(),
 		formDecoder: form.NewDecoder(),
 	}
 
-	registerCustomTypes()
+	registerUUIDCustomType()
+	registerIsoDateCustomType()
+	registerIsoTimeCustomType()
 }
 
+// registerUUIDCustomType registers a custom type function for UUID parsing.
+//
+// It takes an array of strings as input parameters and returns an any type and an error.
+func registerUUIDCustomType() {
+	instance.formDecoder.RegisterCustomTypeFunc(func(vals []string) (any, error) {
+		return uuid.Parse(vals[0])
+	}, uuid.UUID{})
+}
+
+// registerIsoDateCustomType registers a custom type function for ISO date parsing.
+//
+// It takes an array of strings as input parameters and returns an interface{} and an error.
+func registerIsoDateCustomType() {
+	instance.formDecoder.RegisterCustomTypeFunc(func(vals []string) (interface{}, error) {
+		return types.ParseIsoDate(vals[0])
+	}, types.IsoDate{})
+}
+
+// registerIsoTimeCustomType registers a custom type function for ISO time parsing.
+//
+// It takes an array of strings as input parameters and returns an interface{} and an error.
+func registerIsoTimeCustomType() {
+	instance.formDecoder.RegisterCustomTypeFunc(func(vals []string) (interface{}, error) {
+		return types.ParseIsoTime(vals[0])
+	}, types.IsoTime{})
+}
+
+// Struct performs validation on the provided object using the validator instance.
+//
+// Parameter:
+// - object: the object to be validated
+// Return type: error
 func Struct(object any) error {
 	return instance.validator.Struct(object)
 }
 
+// FormDecode decodes the values from the map[string][]string into the provided object using the formDecoder instance.
+//
+// Parameters:
+// - object: the object to be decoded
+// - values: the map containing the values to be decoded
+// Return type: error
 func FormDecode(object any, values map[string][]string) error {
 	return instance.formDecoder.Decode(object, values)
 }
-
-func registerCustomTypes() {
-	instance.formDecoder.RegisterCustomTypeFunc(func(vals []string) (any, error) {
-		return uuid.Parse(vals[0])
-	}, uuid.UUID{})
-}