🔨 Restructure entire project logic

- Moved readers to the config package
- Added an option to read remote config files
- Moved the validation package to the config package and removed the validator dependency
- Moved the customerrors package to the config package
- Replaced fatih/color with jedib0t/go-pretty/v6/text
- Removed proxy check functionality
- Added param, header, cookie, body, and proxy flags to the CLI
- Allowed multiple values for the same key in params, headers, and cookies

types/body.go

@@ -0,0 +1,72 @@
+package types
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+
+	"github.com/jedib0t/go-pretty/v6/text"
+)
+
+type Body []string
+
+func (body Body) String() string {
+	var buffer bytes.Buffer
+	if len(body) == 0 {
+		return string(buffer.Bytes())
+	}
+
+	if len(body) == 1 {
+		buffer.WriteString(body[0])
+		return string(buffer.Bytes())
+	}
+
+	buffer.WriteString(text.FgBlue.Sprint("Random") + "[\n")
+
+	indent := "  "
+
+	displayLimit := 5
+
+	for i, item := range body[:min(len(body), displayLimit)] {
+		if i > 0 {
+			buffer.WriteString(",\n")
+		}
+
+		buffer.WriteString(indent + item)
+	}
+
+	// Add remaining count if there are more items
+	if remainingValues := len(body) - displayLimit; remainingValues > 0 {
+		buffer.WriteString(",\n" + indent + text.FgGreen.Sprintf("+%d bodies", remainingValues))
+	}
+
+	buffer.WriteString("\n]")
+	return string(buffer.Bytes())
+}
+
+func (body *Body) UnmarshalJSON(b []byte) error {
+	var data any
+	if err := json.Unmarshal(b, &data); err != nil {
+		return err
+	}
+
+	switch v := data.(type) {
+	case string:
+		*body = []string{v}
+	case []any:
+		var slice []string
+		for _, item := range v {
+			slice = append(slice, fmt.Sprintf("%v", item))
+		}
+		*body = slice
+	default:
+		return fmt.Errorf("invalid type for Body: %T (should be string or []string)", v)
+	}
+
+	return nil
+}
+
+func (body *Body) Set(value string) error {
+	*body = append(*body, value)
+	return nil
+}

types/config_file.go

@@ -0,0 +1,23 @@
+package types
+
+import "strings"
+
+type FileLocationType int
+
+const (
+	FileLocationTypeLocal FileLocationType = iota
+	FileLocationTypeRemoteHTTP
+)
+
+type ConfigFile string
+
+func (config ConfigFile) String() string {
+	return string(config)
+}
+
+func (config ConfigFile) LocationType() FileLocationType {
+	if strings.HasPrefix(string(config), "http://") || strings.HasPrefix(string(config), "https://") {
+		return FileLocationTypeRemoteHTTP
+	}
+	return FileLocationTypeLocal
+}

types/cookies.go

@@ -0,0 +1,114 @@
+package types
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"strings"
+
+	"github.com/jedib0t/go-pretty/v6/text"
+)
+
+type Cookies []KeyValue[string, []string]
+
+func (cookies Cookies) String() string {
+	var buffer bytes.Buffer
+	if len(cookies) == 0 {
+		return string(buffer.Bytes())
+	}
+
+	indent := "  "
+
+	displayLimit := 3
+
+	for i, item := range cookies {
+		if i > 0 {
+			buffer.WriteString(",\n")
+		}
+
+		if len(item.Value) == 1 {
+			buffer.WriteString(item.Key + ": " + item.Value[0])
+			continue
+		}
+		buffer.WriteString(item.Key + ": " + text.FgBlue.Sprint("Random") + "[\n")
+
+		for ii, v := range item.Value[:min(len(item.Value), displayLimit)] {
+			if ii == len(item.Value)-1 {
+				buffer.WriteString(indent + v + "\n")
+			} else {
+				buffer.WriteString(indent + v + ",\n")
+			}
+		}
+
+		// Add remaining values count if needed
+		if remainingValues := len(item.Value) - displayLimit; remainingValues > 0 {
+			buffer.WriteString(indent + text.FgGreen.Sprintf("+%d values", remainingValues) + "\n")
+		}
+
+		buffer.WriteString("]")
+	}
+
+	// Add remaining key-value pairs count if needed
+	if remainingPairs := len(cookies) - displayLimit; remainingPairs > 0 {
+		buffer.WriteString(",\n" + text.FgGreen.Sprintf("+%d cookies", remainingPairs))
+	}
+
+	return string(buffer.Bytes())
+}
+
+func (cookies *Cookies) UnmarshalJSON(b []byte) error {
+	var data []map[string]any
+	if err := json.Unmarshal(b, &data); err != nil {
+		return err
+	}
+
+	for _, item := range data {
+		for key, value := range item {
+			switch parsedValue := value.(type) {
+			case string:
+				*cookies = append(*cookies, KeyValue[string, []string]{Key: key, Value: []string{parsedValue}})
+			case []any:
+				parsedStr := make([]string, len(parsedValue))
+				for i, item := range parsedValue {
+					parsedStr[i] = fmt.Sprintf("%v", item)
+				}
+				*cookies = append(*cookies, KeyValue[string, []string]{Key: key, Value: parsedStr})
+			default:
+				return fmt.Errorf("unsupported type for cookies expected string or []string, got %T", parsedValue)
+			}
+		}
+	}
+
+	return nil
+}
+
+func (cookies *Cookies) Set(value string) error {
+	parts := strings.SplitN(value, "=", 2)
+	switch len(parts) {
+	case 0:
+		cookies.AppendByKey("", "")
+	case 1:
+		cookies.AppendByKey(parts[0], "")
+	case 2:
+		cookies.AppendByKey(parts[0], parts[1])
+	}
+
+	return nil
+}
+
+func (cookies *Cookies) AppendByKey(key string, value string) {
+	if existingValue := cookies.GetValue(key); existingValue != nil {
+		*cookies = append(*cookies, KeyValue[string, []string]{Key: key, Value: append(existingValue, value)})
+	} else {
+		*cookies = append(*cookies, KeyValue[string, []string]{Key: key, Value: []string{value}})
+	}
+}
+
+func (cookies *Cookies) GetValue(key string) []string {
+	for _, cookie := range *cookies {
+		if cookie.Key == key {
+			return cookie.Value
+		}
+	}
+	return nil
+}

types/duration.go

@@ -0,0 +1,36 @@
+package types
+
+import (
+	"encoding/json"
+	"errors"
+	"time"
+)
+
+type Timeout struct {
+	time.Duration
+}
+
+func (timeout *Timeout) UnmarshalJSON(b []byte) error {
+	var v any
+	if err := json.Unmarshal(b, &v); err != nil {
+		return err
+	}
+	switch value := v.(type) {
+	case float64:
+		timeout.Duration = time.Duration(value)
+		return nil
+	case string:
+		var err error
+		timeout.Duration, err = time.ParseDuration(value)
+		if err != nil {
+			return errors.New("Timeout is invalid (e.g. 400ms, 1s, 5m, 1h)")
+		}
+		return nil
+	default:
+		return errors.New("Timeout is invalid (e.g. 400ms, 1s, 5m, 1h)")
+	}
+}
+
+func (timeout Timeout) MarshalJSON() ([]byte, error) {
+	return json.Marshal(timeout.Duration.String())
+}

types/errors.go

@@ -0,0 +1,10 @@
+package types
+
+import (
+	"errors"
+)
+
+var (
+	ErrInterrupt = errors.New("interrupted")
+	ErrTimeout   = errors.New("timeout")
+)

types/headers.go

@@ -0,0 +1,114 @@
+package types
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"strings"
+
+	"github.com/jedib0t/go-pretty/v6/text"
+)
+
+type Headers []KeyValue[string, []string]
+
+func (headers Headers) String() string {
+	var buffer bytes.Buffer
+	if len(headers) == 0 {
+		return string(buffer.Bytes())
+	}
+
+	indent := "  "
+
+	displayLimit := 3
+
+	for i, item := range headers {
+		if i > 0 {
+			buffer.WriteString(",\n")
+		}
+
+		if len(item.Value) == 1 {
+			buffer.WriteString(item.Key + ": " + item.Value[0])
+			continue
+		}
+		buffer.WriteString(item.Key + ": " + text.FgBlue.Sprint("Random") + "[\n")
+
+		for ii, v := range item.Value[:min(len(item.Value), displayLimit)] {
+			if ii == len(item.Value)-1 {
+				buffer.WriteString(indent + v + "\n")
+			} else {
+				buffer.WriteString(indent + v + ",\n")
+			}
+		}
+
+		// Add remaining values count if needed
+		if remainingValues := len(item.Value) - displayLimit; remainingValues > 0 {
+			buffer.WriteString(indent + text.FgGreen.Sprintf("+%d values", remainingValues) + "\n")
+		}
+
+		buffer.WriteString("]")
+	}
+
+	// Add remaining key-value pairs count if needed
+	if remainingPairs := len(headers) - displayLimit; remainingPairs > 0 {
+		buffer.WriteString(",\n" + text.FgGreen.Sprintf("+%d headers", remainingPairs))
+	}
+
+	return string(buffer.Bytes())
+}
+
+func (headers *Headers) UnmarshalJSON(b []byte) error {
+	var data []map[string]any
+	if err := json.Unmarshal(b, &data); err != nil {
+		return err
+	}
+
+	for _, item := range data {
+		for key, value := range item {
+			switch parsedValue := value.(type) {
+			case string:
+				*headers = append(*headers, KeyValue[string, []string]{Key: key, Value: []string{parsedValue}})
+			case []any:
+				parsedStr := make([]string, len(parsedValue))
+				for i, item := range parsedValue {
+					parsedStr[i] = fmt.Sprintf("%v", item)
+				}
+				*headers = append(*headers, KeyValue[string, []string]{Key: key, Value: parsedStr})
+			default:
+				return fmt.Errorf("unsupported type for headers expected string or []string, got %T", parsedValue)
+			}
+		}
+	}
+
+	return nil
+}
+
+func (headers *Headers) Set(value string) error {
+	parts := strings.SplitN(value, ":", 2)
+	switch len(parts) {
+	case 0:
+		headers.AppendByKey("", "")
+	case 1:
+		headers.AppendByKey(parts[0], "")
+	case 2:
+		headers.AppendByKey(parts[0], parts[1])
+	}
+
+	return nil
+}
+
+func (headers *Headers) AppendByKey(key string, value string) {
+	if existingValue := headers.GetValue(key); existingValue != nil {
+		*headers = append(*headers, KeyValue[string, []string]{Key: key, Value: append(existingValue, value)})
+	} else {
+		*headers = append(*headers, KeyValue[string, []string]{Key: key, Value: []string{value}})
+	}
+}
+
+func (headers *Headers) GetValue(key string) []string {
+	for _, header := range *headers {
+		if header.Key == key {
+			return header.Value
+		}
+	}
+	return nil
+}

types/key_value.go

@@ -0,0 +1,6 @@
+package types
+
+type KeyValue[K comparable, V any] struct {
+	Key   K
+	Value V
+}

types/option.go

@@ -1,89 +0,0 @@
-package types
-
-import (
-	"encoding/json"
-	"errors"
-)
-
-type NonNilT interface {
-	~int | ~float64 | ~string | ~bool
-}
-
-type Option[T NonNilT] interface {
-	IsNone() bool
-	ValueOrErr() (T, error)
-	ValueOr(def T) T
-	ValueOrPanic() T
-	SetValue(value T)
-	SetNone()
-	UnmarshalJSON(data []byte) error
-}
-
-// Don't call this struct directly, use NewOption[T] or NewNoneOption[T] instead.
-type option[T NonNilT] struct {
-	// value holds the actual value of the Option if it is not None.
-	value T
-	// none indicates whether the Option is None (i.e., has no value).
-	none bool
-}
-
-func (o *option[T]) IsNone() bool {
-	return o.none
-}
-
-// If the Option is None, it will return zero value of the type and an error.
-func (o *option[T]) ValueOrErr() (T, error) {
-	if o.IsNone() {
-		return o.value, errors.New("Option is None")
-	}
-	return o.value, nil
-}
-
-// If the Option is None, it will return the default value.
-func (o *option[T]) ValueOr(def T) T {
-	if o.IsNone() {
-		return def
-	}
-	return o.value
-}
-
-// If the Option is None, it will panic.
-func (o *option[T]) ValueOrPanic() T {
-	if o.IsNone() {
-		panic("Option is None")
-	}
-	return o.value
-}
-
-func (o *option[T]) SetValue(value T) {
-	o.value = value
-	o.none = false
-}
-
-func (o *option[T]) SetNone() {
-	var zeroValue T
-	o.value = zeroValue
-	o.none = true
-}
-
-func (o *option[T]) UnmarshalJSON(data []byte) error {
-	if string(data) == "null" || len(data) == 0 {
-		o.SetNone()
-		return nil
-	}
-
-	if err := json.Unmarshal(data, &o.value); err != nil {
-		o.SetNone()
-		return err
-	}
-	o.none = false
-	return nil
-}
-
-func NewOption[T NonNilT](value T) *option[T] {
-	return &option[T]{value: value}
-}
-
-func NewNoneOption[T NonNilT]() *option[T] {
-	return &option[T]{none: true}
-}

types/params.go

@@ -0,0 +1,114 @@
+package types
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"strings"
+
+	"github.com/jedib0t/go-pretty/v6/text"
+)
+
+type Params []KeyValue[string, []string]
+
+func (params Params) String() string {
+	var buffer bytes.Buffer
+	if len(params) == 0 {
+		return string(buffer.Bytes())
+	}
+
+	indent := "  "
+
+	displayLimit := 3
+
+	for i, item := range params {
+		if i > 0 {
+			buffer.WriteString(",\n")
+		}
+
+		if len(item.Value) == 1 {
+			buffer.WriteString(item.Key + ": " + item.Value[0])
+			continue
+		}
+		buffer.WriteString(item.Key + ": " + text.FgBlue.Sprint("Random") + "[\n")
+
+		for ii, v := range item.Value[:min(len(item.Value), displayLimit)] {
+			if ii == len(item.Value)-1 {
+				buffer.WriteString(indent + v + "\n")
+			} else {
+				buffer.WriteString(indent + v + ",\n")
+			}
+		}
+
+		// Add remaining values count if needed
+		if remainingValues := len(item.Value) - displayLimit; remainingValues > 0 {
+			buffer.WriteString(indent + text.FgGreen.Sprintf("+%d values", remainingValues) + "\n")
+		}
+
+		buffer.WriteString("]")
+	}
+
+	// Add remaining key-value pairs count if needed
+	if remainingPairs := len(params) - displayLimit; remainingPairs > 0 {
+		buffer.WriteString(",\n" + text.FgGreen.Sprintf("+%d params", remainingPairs))
+	}
+
+	return string(buffer.Bytes())
+}
+
+func (params *Params) UnmarshalJSON(b []byte) error {
+	var data []map[string]any
+	if err := json.Unmarshal(b, &data); err != nil {
+		return err
+	}
+
+	for _, item := range data {
+		for key, value := range item {
+			switch parsedValue := value.(type) {
+			case string:
+				*params = append(*params, KeyValue[string, []string]{Key: key, Value: []string{parsedValue}})
+			case []any:
+				parsedStr := make([]string, len(parsedValue))
+				for i, item := range parsedValue {
+					parsedStr[i] = fmt.Sprintf("%v", item)
+				}
+				*params = append(*params, KeyValue[string, []string]{Key: key, Value: parsedStr})
+			default:
+				return fmt.Errorf("unsupported type for params expected string or []string, got %T", parsedValue)
+			}
+		}
+	}
+
+	return nil
+}
+
+func (params *Params) Set(value string) error {
+	parts := strings.SplitN(value, "=", 2)
+	switch len(parts) {
+	case 0:
+		params.AppendByKey("", "")
+	case 1:
+		params.AppendByKey(parts[0], "")
+	case 2:
+		params.AppendByKey(parts[0], parts[1])
+	}
+
+	return nil
+}
+
+func (params *Params) AppendByKey(key string, value string) {
+	if existingValue := params.GetValue(key); existingValue != nil {
+		*params = append(*params, KeyValue[string, []string]{Key: key, Value: append(existingValue, value)})
+	} else {
+		*params = append(*params, KeyValue[string, []string]{Key: key, Value: []string{value}})
+	}
+}
+
+func (params *Params) GetValue(key string) []string {
+	for _, param := range *params {
+		if param.Key == key {
+			return param.Value
+		}
+	}
+	return nil
+}

types/proxies.go

@@ -0,0 +1,86 @@
+package types
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"net/url"
+
+	"github.com/jedib0t/go-pretty/v6/text"
+)
+
+type Proxies []url.URL
+
+func (proxies Proxies) String() string {
+	var buffer bytes.Buffer
+	if len(proxies) == 0 {
+		return string(buffer.Bytes())
+	}
+
+	if len(proxies) == 1 {
+		buffer.WriteString(proxies[0].String())
+		return string(buffer.Bytes())
+	}
+
+	buffer.WriteString(text.FgBlue.Sprint("Random") + "[\n")
+
+	indent := "  "
+
+	displayLimit := 5
+
+	for i, item := range proxies[:min(len(proxies), displayLimit)] {
+		if i > 0 {
+			buffer.WriteString(",\n")
+		}
+
+		buffer.WriteString(indent + item.String())
+	}
+
+	// Add remaining count if there are more items
+	if remainingValues := len(proxies) - displayLimit; remainingValues > 0 {
+		buffer.WriteString(",\n" + indent + text.FgGreen.Sprintf("+%d proxies", remainingValues))
+	}
+
+	buffer.WriteString("\n]")
+	return string(buffer.Bytes())
+}
+
+func (proxies *Proxies) UnmarshalJSON(b []byte) error {
+	var data any
+	if err := json.Unmarshal(b, &data); err != nil {
+		return err
+	}
+
+	switch v := data.(type) {
+	case string:
+		parsed, err := url.Parse(v)
+		if err != nil {
+			return err
+		}
+		*proxies = []url.URL{*parsed}
+	case []any:
+		var urls []url.URL
+		for _, item := range v {
+			url, err := url.Parse(item.(string))
+			if err != nil {
+				return err
+			}
+			urls = append(urls, *url)
+		}
+		*proxies = urls
+	default:
+		return fmt.Errorf("invalid type for Body: %T (should be URL or []URL)", v)
+	}
+
+	return nil
+}
+
+func (proxies *Proxies) Set(value string) error {
+	parsedURL, err := url.Parse(value)
+	if err != nil {
+		return err
+	}
+
+	*proxies = append(*proxies, *parsedURL)
+	return nil
+}

types/request_url.go

@@ -0,0 +1,44 @@
+package types
+
+import (
+	"encoding/json"
+	"errors"
+	"net/url"
+)
+
+type RequestURL struct {
+	url.URL
+}
+
+func (requestURL *RequestURL) UnmarshalJSON(data []byte) error {
+	var urlStr string
+	if err := json.Unmarshal(data, &urlStr); err != nil {
+		return err
+	}
+
+	parsedURL, err := url.Parse(urlStr)
+	if err != nil {
+		return errors.New("Request URL is invalid")
+	}
+
+	requestURL.URL = *parsedURL
+	return nil
+}
+
+func (requestURL RequestURL) MarshalJSON() ([]byte, error) {
+	return json.Marshal(requestURL.URL.String())
+}
+
+func (requestURL RequestURL) String() string {
+	return requestURL.URL.String()
+}
+
+func (requestURL *RequestURL) Set(value string) error {
+	parsedURL, err := url.Parse(value)
+	if err != nil {
+		return err
+	}
+
+	requestURL.URL = *parsedURL
+	return nil
+}