Merge pull request #98 from sev-2/feature/paginate

enhance functionality

controller.go

@@ -1,6 +1,7 @@
 package raiden
 
 import (
+	"context"
 	"encoding/json"
 	"errors"
 	"fmt"
@@ -305,7 +306,7 @@ func (rc RestController) Patch(ctx Context) error {
 		return err
 	}
 
-	if err1 := Validate(model); err1 != nil {
+	if err1 := Validate(ctx.RequestContext(), model); err1 != nil {
 		return err1
 	}
 
@@ -328,7 +329,7 @@ func (rc RestController) Post(ctx Context) error {
 		return err
 	}
 
-	if err1 := Validate(model); err1 != nil {
+	if err1 := Validate(ctx.RequestContext(), model); err1 != nil {
 		return err1
 	}
 
@@ -343,7 +344,7 @@ func (rc RestController) Put(ctx Context) error {
 		return err
 	}
 
-	if err1 := Validate(model); err1 != nil {
+	if err1 := Validate(ctx.RequestContext(), model); err1 != nil {
 		return err1
 	}
 
@@ -562,7 +563,11 @@ func MarshallAndValidate(ctx *fasthttp.RequestCtx, controller any) error {
 	}
 
 	// validate marshalled payload
-	if err := Validate(payloadPtr); err != nil {
+	reqContext := context.WithValue(
+		context.Background(),
+		MethodContextKey, string(ctx.Request.Header.Method()),
+	)
+	if err := Validate(reqContext, payloadPtr); err != nil {
 		return err
 	}
 
@@ -602,8 +607,14 @@ func setPayloadValue(fieldValue reflect.Value, value string) error {
 			return fmt.Errorf("%s : must be integer value", fieldValue.Type().Name())
 		}
 		fieldValue.SetInt(int64(intValue))
+	case reflect.Ptr:
+		// Handle pointer types
+		if fieldValue.IsNil() {
+			fieldValue.Set(reflect.New(fieldValue.Type().Elem())) // Allocate new value
+		}
+		return setPayloadValue(fieldValue.Elem(), value)
 	default:
-		return fmt.Errorf("%s : unsupported field type %s", fieldValue.Type().Name(), fieldValue.Kind())
+		fieldValue.SetZero()
 	}
 
 	return nil

controller_test.go

@@ -402,6 +402,29 @@ func TestMarshallAndValidate(t *testing.T) {
 
 }
 
+func TestMarshallAndValidate_ByMethod(t *testing.T) {
+	ctx := newMockCtx()
+	type Request struct {
+		Search   string `query:"q"`
+		Resource string `json:"resource" validate:"requiredForMethod=Post"`
+	}
+	type Controller struct {
+		raiden.ControllerBase
+		Payload *Request
+	}
+	controller := &Controller{}
+
+	ctx.Request.Header.SetMethod(fasthttp.MethodGet)
+	ctx.SetBodyString("{\"resource\":\"\"}")
+
+	err := raiden.MarshallAndValidate(ctx.RequestContext(), controller)
+	assert.NoError(t, err)
+
+	ctx.Request.Header.SetMethod(fasthttp.MethodPost)
+	err = raiden.MarshallAndValidate(ctx.RequestContext(), controller)
+	assert.Error(t, err)
+}
+
 func TestController_PassDataRestPost(t *testing.T) {
 	var reqCtx fasthttp.RequestCtx
 	context := raiden.Ctx{

pkg/client/client.go

@@ -5,8 +5,6 @@ import (
 	"errors"
 	"fmt"
 	"reflect"
-	"strconv"
-	"strings"
 	"time"
 
 	"github.com/sev-2/raiden/pkg/logger"
@@ -15,7 +13,6 @@ import (
 
 var (
 	headerContentTypeJson = []byte("application/json")
-	httpClientInstance    Client
 	DefaultTimeout        = time.Duration(20000) * time.Millisecond
 	Logger                = logger.HcLog().Named("supabase.client")
 )
@@ -43,29 +40,20 @@ type DefaultResponse struct {
 	Message string `json:"message"`
 }
 
-func getClient() Client {
+var DefaultGetClientFn = func() Client {
 	maxIdleConnDuration := time.Hour * 1
-
-	httpClientInstance = &fasthttp.Client{
+	return &fasthttp.Client{
 		ReadTimeout:                   DefaultTimeout,
 		WriteTimeout:                  DefaultTimeout,
 		MaxIdleConnDuration:           maxIdleConnDuration,
 		NoDefaultUserAgentHeader:      true,
 		DisableHeaderNamesNormalizing: true,
 		DisablePathNormalizing:        true,
 		MaxConnWaitTimeout:            DefaultTimeout,
-		Dial: (&fasthttp.TCPDialer{
-			Concurrency:      4096,
-			DNSCacheDuration: time.Hour,
-		}).Dial,
 	}
-
-	return httpClientInstance
 }
 
-func SetClient(c Client) {
-	httpClientInstance = c
-}
+var GetClientFn = DefaultGetClientFn
 
 func SendRequest(method string, url string, body []byte, timeout time.Duration, reqInterceptor RequestInterceptor, resInterceptor ResponseInterceptor) (rawBody []byte, err error) {
 	reqTimeout := DefaultTimeout
@@ -94,7 +82,7 @@ func SendRequest(method string, url string, body []byte, timeout time.Duration,
 	Logger.Trace("request", "headers", string(req.Header.Header()))
 	Logger.Trace("request", "body", string(req.Body()))
 
-	err = getClient().DoTimeout(req, resp, reqTimeout)
+	err = GetClientFn().DoTimeout(req, resp, reqTimeout)
 	if err != nil {
 		logger.HcLog().Error("[SendRequest][DoTimeout]", "err-type", reflect.TypeOf(err).String(), "err-msg", err.Error())
 		return
@@ -115,7 +103,11 @@ func SendRequest(method string, url string, body []byte, timeout time.Duration,
 
 	statusCode := resp.StatusCode()
 
-	if !strings.HasPrefix(strconv.Itoa(statusCode), "2") {
+	Logger.Trace("response", "statusCode", statusCode)
+	Logger.Trace("response", "header", resp.Header.String())
+	Logger.Trace("response", "body", string(resp.Body()))
+
+	if statusCode > 399 {
 		err = fmt.Errorf("invalid HTTP response code: %d", statusCode)
 		if resp.Body() != nil && len(resp.Body()) > 0 {
 			Logger.Error(string(resp.Body()))

pkg/client/client_test.go

@@ -5,39 +5,29 @@ import (
 	"time"
 
 	"github.com/sev-2/raiden/pkg/client"
+	"github.com/sev-2/raiden/pkg/mock"
 	"github.com/stretchr/testify/assert"
 	"github.com/valyala/fasthttp"
 )
 
-type MockClient struct {
-	DoFn        func(*fasthttp.Request, *fasthttp.Response) error
-	DoTimeoutFn func(*fasthttp.Request, *fasthttp.Response, time.Duration) error
-}
-
-func (m *MockClient) Do(req *fasthttp.Request, rest *fasthttp.Response) error {
-	return m.DoFn(req, rest)
-}
-
-func (m *MockClient) DoTimeout(req *fasthttp.Request, rest *fasthttp.Response, timeout time.Duration) error {
-	return m.DoTimeoutFn(req, rest, timeout)
-}
-
 func TestSendRequest(t *testing.T) {
 	t.Parallel()
 
-	c := MockClient{
+	c := mock.MockClient{
 		DoTimeoutFn: func(r1 *fasthttp.Request, r2 *fasthttp.Response, d time.Duration) error {
 			r2.SetBodyRaw([]byte("{ \"message\": \"hello from home\" }"))
 			return nil
 		},
 	}
 
-	client.SetClient(&c)
+	client.GetClientFn = func() client.Client {
+		return &c
+	}
 
 	type Response struct {
 		Message string `json:"message"`
 	}
 
 	rs, _ := client.Get[Response]("http://localhost:8080", 1000000, nil, nil)
-	assert.Equal(t, "", rs.Message)
+	assert.Equal(t, "hello from home", rs.Message)
 }

pkg/db/db.go

@@ -119,6 +119,10 @@ func (q Query) Single(model interface{}) error {
 	return nil
 }
 
+func (q Query) GetQueryURI() string {
+	return buildQueryURI(q)
+}
+
 func (q Query) GetUrl() string {
 	urlQuery := buildQueryURI(q)
 

pkg/generator/model.go

@@ -203,7 +203,15 @@ func MapTableAttributes(projectName string, table objects.Table, mapDataType map
 				importPackageName = "encoding/json"
 			}
 
-			if column.Type == "postgres.Point" || column.Type == "*postgres.Point" {
+			// custom type
+			postgresCustomTypes := map[string]bool{
+				"postgres.Point":     true,
+				"*postgres.Point":    true,
+				"postgres.DateTime":  true,
+				"*postgres.DateTime": true,
+			}
+
+			if postgresCustomTypes[column.Type] {
 				importPackageName = "github.com/sev-2/raiden/pkg/postgres"
 			}
 

pkg/generator/type.go

@@ -61,10 +61,6 @@ func (r *{{.Name | ToGoIdentifier }}) Enums() []string {
 	return {{ .Enums }}
 }
 
-func (r *{{.Name | ToGoIdentifier }}) Attributes() []string {
-	return {{ .Attributes }}
-}
-
 func (r *{{.Name | ToGoIdentifier }}) Comment() *string {
 	return {{ .Comment }}
 }

pkg/generator/type_test.go

@@ -25,7 +25,7 @@ func TestGenerateTypes(t *testing.T) {
 			Schema:     "public",
 			Format:     "",
 			Enums:      []string{"test_1", "test_2"},
-			Attributes: []string{},
+			Attributes: []objects.TypeAttribute{},
 			Comment:    nil,
 		},
 	}

pkg/mock/fasthttp_client.go

@@ -0,0 +1,20 @@
+package mock
+
+import (
+	"time"
+
+	"github.com/valyala/fasthttp"
+)
+
+type MockClient struct {
+	DoFn        func(*fasthttp.Request, *fasthttp.Response) error
+	DoTimeoutFn func(*fasthttp.Request, *fasthttp.Response, time.Duration) error
+}
+
+func (m *MockClient) Do(req *fasthttp.Request, rest *fasthttp.Response) error {
+	return m.DoFn(req, rest)
+}
+
+func (m *MockClient) DoTimeout(req *fasthttp.Request, rest *fasthttp.Response, timeout time.Duration) error {
+	return m.DoTimeoutFn(req, rest, timeout)
+}

pkg/paginate/driver.go

@@ -0,0 +1,13 @@
+package paginate
+
+import (
+	"context"
+)
+
+type Item map[string]any
+
+type Driver interface {
+	Paginate(ctx context.Context, statement string, page, limit int, withCount bool) (data []Item, cont int, err error)
+	CursorPaginateNext(ctx context.Context, statement string, cursorRefColumn string, cursor any, limit int, withCount bool) (data []Item, count int, prevCursor any, nextCursor any, err error)
+	CursorPaginatePrev(ctx context.Context, statement string, cursorRefColumn string, cursor any, limit int, withCount bool) (data []Item, count int, prevCursor any, nextCursor any, err error)
+}