refactor: use new input parser

Author: v1def

collection.go

@@ -12,6 +12,8 @@ import (
 	"fmt"
 	"net/http"
 	"net/url"
+
+	"github.com/durudex/go-polybase/input"
 )
 
 type Collection[T any] interface {
@@ -38,62 +40,61 @@ func (c *collection[T]) Get(ctx context.Context) *Response[T] {
 	defer recoverFunc(ctx, c.client.Config().RecoverHandler)
 
 	req := &Request{
-		Endpoint: fmt.Sprintf("/collections/%s/records", c.name),
+		Endpoint: fmt.Sprintf(recordsEndpointFormat, c.name),
 		Method:   http.MethodGet,
 	}
 
 	var resp Response[T]
 
 	if err := c.client.MakeRequest(ctx, req, &resp); err != nil {
-		panic("error getting collection records: " + err.Error())
+		panic("error: getting collection records: " + err.Error())
 	}
 
 	return &resp
 }
 
 func (c *collection[T]) Before(cursor string) Query[T] {
 	return newQuery[T](c.client,
-		fmt.Sprintf("/collections/%s/records", c.name)).Before(cursor)
+		fmt.Sprintf(recordsEndpointFormat, c.name)).Before(cursor)
 }
 
 func (c *collection[T]) After(cursor string) Query[T] {
 	return newQuery[T](c.client,
-		fmt.Sprintf("/collections/%s/records", c.name)).After(cursor)
+		fmt.Sprintf(recordsEndpointFormat, c.name)).After(cursor)
 }
 
 func (c *collection[T]) Limit(num int) Query[T] {
 	return newQuery[T](c.client,
-		fmt.Sprintf("/collections/%s/records", c.name)).Limit(num)
+		fmt.Sprintf(recordsEndpointFormat, c.name)).Limit(num)
 }
 
 func (c *collection[T]) Sort(field string, direction ...string) Query[T] {
 	return newQuery[T](c.client,
-		fmt.Sprintf("/collections/%s/records", c.name)).Sort(field, direction...)
+		fmt.Sprintf(recordsEndpointFormat, c.name)).Sort(field, direction...)
 }
 
 func (c *collection[T]) Where(field string, op WhereOperator, value any) Query[T] {
 	return newQuery[T](c.client,
-		fmt.Sprintf("/collections/%s/records", c.name)).Where(field, op, value)
+		fmt.Sprintf(recordsEndpointFormat, c.name)).Where(field, op, value)
 }
 
 func (c *collection[T]) Record(id string) RecordDoer[T] {
-	return newRecordDoer[T](c.client,
-		fmt.Sprintf("/collections/%s/records/%s", c.name, url.QueryEscape(id)))
+	return newRecordDoer[T](c.client, c.name, id)
 }
 
 func (c *collection[T]) Create(ctx context.Context, args ...any) *SingleResponse[T] {
 	defer recoverFunc(ctx, c.client.Config().RecoverHandler)
 
 	req := &Request{
-		Endpoint: fmt.Sprintf("/collections/%s/records", c.name),
+		Endpoint: fmt.Sprintf(recordsEndpointFormat, c.name),
 		Method:   http.MethodPost,
-		Body:     Body{Args: ParseInput(args)},
+		Body:     Body{Args: input.Parse(args)},
 	}
 
 	var resp SingleResponse[T]
 
 	if err := c.client.MakeRequest(ctx, req, &resp); err != nil {
-		panic("error creating a new record: " + err.Error())
+		panic("error: creating a new record instance: " + err.Error())
 	}
 
 	return &resp

input.go

@@ -12,6 +12,13 @@ import (
 	"fmt"
 	"net/http"
 	"net/url"
+
+	"github.com/durudex/go-polybase/input"
+)
+
+const (
+	recordsEndpointFormat = "/collections/%s/records"
+	recordEndpointFormat  = recordsEndpointFormat + "/%s"
 )
 
 // Record structure stores the Polybase record.
@@ -38,11 +45,19 @@ type RecordDoer[T any] interface {
 type recordDoer[T any] struct {
 	client   Client
 	endpoint string
+	config   *input.Foreign
 }
 
 // newRecordDoer function returns a new record doer.
-func newRecordDoer[T any](client Client, endpoint string) RecordDoer[T] {
-	return &recordDoer[T]{client: client, endpoint: endpoint}
+func newRecordDoer[T any](client Client, name, id string) RecordDoer[T] {
+	endpoint := fmt.Sprintf(recordEndpointFormat, name, url.QueryEscape(id))
+	config := &input.Foreign{CollectionID: name, ID: id}
+
+	return &recordDoer[T]{
+		client:   client,
+		endpoint: endpoint,
+		config:   config,
+	}
 }
 
 // Get method sends a request to getting collection record by the specified ID and decodes
@@ -58,7 +73,7 @@ func (r *recordDoer[T]) Get(ctx context.Context) *SingleResponse[T] {
 	var resp SingleResponse[T]
 
 	if err := r.client.MakeRequest(ctx, req, &resp); err != nil {
-		panic("error getting record: " + err.Error())
+		panic("error: getting record: " + err.Error())
 	}
 
 	return &resp
@@ -71,14 +86,16 @@ func (r *recordDoer[T]) Call(ctx context.Context, fc string, args ...any) *Singl
 	req := &Request{
 		Endpoint: r.endpoint + fmt.Sprintf("/call/%s", url.QueryEscape(fc)),
 		Method:   http.MethodPost,
-		Body:     Body{Args: ParseInput(args)},
+		Body:     Body{Args: input.Parse(args)},
 	}
 
 	var resp SingleResponse[T]
 
 	if err := r.client.MakeRequest(ctx, req, &resp); err != nil {
-		panic("error call collection function: " + err.Error())
+		panic("error: call collection function: " + err.Error())
 	}
 
 	return &resp
 }
+
+func (r *recordDoer[T]) Reference() *input.Foreign { return r.config }