updated string to type

* added central file for str operations and funcs
* fixed and added tests
* (fixed) README

Author: CodeShellDev

.github/templates/README.template.md

@@ -6,11 +6,11 @@
 
 Get the latest version of the `docker-compose.yaml` file:
 
-And add secure Token(s) to `API__TOKEN` / `API__TOKENS`. See [API\_\_TOKEN(s)](#api-tokens)
+And add secure Token(s) to `API__TOKEN` / `API__TOKENS`. See [API TOKEN(s)](#api-tokens)
 
 > [!IMPORTANT]
 > This Documentation will be using `sec-signal-api:8880` as the service host,
-> this **won't work**, instead use your containers IP + Port.
+> this **is just for simplicty**, instead use your containers or hosts IP + Port.
 > Or a hostname if applicable. See [Reverse Proxy](#reverse-proxy)
 
 ```yaml
@@ -47,20 +47,20 @@ Secured Signal API provides 3 Ways to Authenticate
 
 ### Bearer
 
-To Authenticate add `Authorization: Bearer API__TOKEN` to your request Headers
+To Authenticate add `Authorization: Bearer API_TOKEN` to your request Headers
 
 ### Basic Auth
 
 To use Basic Auth as Authorization Method add `Authorization: Basic BASE64_STRING` to your Headers
 
 User is `api` (LOWERCASE)
 
-Formatting for `BASE64_STRING` = `user:API__TOKEN`.
+Formatting for `BASE64_STRING` = `user:API_TOKEN`.
 
 example:
 
 ```bash
-echo "api:API__TOKEN" | base64
+echo "api:API_TOKEN" | base64
 ```
 
 => `YXBpOkFQSV9LRVkK`
@@ -73,17 +73,17 @@ in this case you can use **Query Auth**.
 Here is a simple example:
 
 ```bash
-curl -X POST http://sec-signal-api:8880/v2/send?@authorization=API__TOKEN
+curl -X POST http://sec-signal-api:8880/v2/send?@authorization=API_TOKEN
 ```
 
-Notice the `@` infront of `authorization`. See [Formatting](#format).
+Notice the `@` infront of `authorization`. See [KeyValue Pair Injection](#keyvalue-pair-injection).
 
 ### Example
 
 To send a message to 1234567:
 
 ```bash
-curl -X POST -H "Content-Type: application/json" -H "Authorization: Bearer API__TOKEN" -d '{"message": "Hello World!", "recipients": ["1234567"]}' http://sec-signal-api:8880/v2/send
+curl -X POST -H "Content-Type: application/json" -H "Authorization: Bearer API_TOKEN" -d '{"message": "Hello World!", "recipients": ["1234567"]}' http://sec-signal-api:8880/v2/send
 ```
 
 ### Advanced
@@ -121,34 +121,41 @@ http://sec-signal-api:8880/v1/receive/{{.NUMBER}}
 
 In some cases you may not be able to access / modify the Request Body, in that case specify needed values in the Request Query:
 
-Supported types include **strings**, **ints** and **arrays**
-
 `http://sec-signal-api:8880/?@key=value`
 
-| type       | example |
-| :--------- | :------ |
-| string     | abc     |
-| int        | 123     |
-| array      | [1,2,3] |
-| array(int) | 1,2,3   |
-| array(str) | a,b,c   |
-
-##### Format
-
 In order to differentiate Injection Queries and _regular_ Queries
 you have to add `@` in front of any KeyValue Pair assignment.
 
+Supported types include **strings**, **ints** and **arrays**. See [Formatting](#string-to-type).
+
 ## Environment Variables
 
+### String To Type
+
+In the Environment the only allowed type is a string so to not have to always use a json string you can use the following types,
+if you format them correctly...
+
+| type       | example           |
+| :--------- | :---------------- |
+| string     | abc               |
+| string     | +123              |
+| int        | 123               |
+| int        | -123              |
+| json       | {"a":"b","c":"d"} |
+| array(int) | [1,2,3]           |
+| array(str) | [a,b,c]           |
+
+This formatting applies to almost every situation where the only (allowed) Input Type is a string and other Output Types are needed.
+
 ### API Token(s)
 
-Both `API__TOKEN` and `API__TOKENS` support multiple Tokens seperated by a `,` **Comma**.
+Both `API__TOKEN` and `API__TOKENS` support multiple Tokens seperated by a `,` **Comma** and `[]` **Brackets**. See [Formatting](#string-to-type).
 During Authentication Secured Signal API will try to match the given Token against the list of Tokens inside of these Variables.
 
 ```yaml
 environment:
-  API__TOKEN: "token1, token2, token3"
-  API__TOKENS: "token1, token2, token3"
+  API__TOKEN: [token1, token2, token3]
+  API__TOKENS: [token1, token2, token3]
 ```
 
 > [!IMPORTANT]
@@ -215,7 +222,7 @@ Set this Environment Variable to automatically provide default Recipients:
 ```yaml
 environment:
   RECIPIENTS: |
-    user.id, 000, 001, group.id,
+    [ user.id, 000, 001, group.id ]
 ```
 
 example:

tests/string_test.go

@@ -0,0 +1,78 @@
+package tests
+
+import (
+	"reflect"
+	"testing"
+
+	"github.com/codeshelldev/secured-signal-api/utils/safestrings"
+)
+
+func TestStringEscaping(t *testing.T) {
+	str1 := `\#`
+
+	res1 := safestrings.IsEscaped(str1, "#")
+
+	if !res1 {
+		t.Error("Expected: ", str1, " == true", "; Got: ", str1, " == ", res1)
+	}
+
+	str2 := "#"
+
+	res2 := safestrings.IsEscaped(str2, "#")
+
+	if res2 {
+		t.Error("Expected: ", str2, " == false", "; Got: ", str2, " == ", res2)
+	}
+
+	str3 := `#\#`
+
+	res3 := safestrings.Contains(str3, "#")
+
+	if !res3 {
+		t.Error("Expected: ", str3, " == true", "; Got: ", str3, " == ", res3)
+	}
+}
+
+func TestStringEnclosement(t *testing.T) {
+	str1 := "[enclosed]"
+
+	res1 := safestrings.IsEnclosedBy(str1, `[`, `]`)
+
+	if !res1 {
+		t.Error("Expected: ", str1, " == true", "; Got: ", str1, " == ", res1)
+	}
+
+	str2 := `\[enclosed]`
+
+	res2 := safestrings.IsEnclosedBy(str2, `[`, `]`)
+
+	if res2 {
+		t.Error("Expected: ", str2, " == false", "; Got: ", str2, " == ", res2)
+	}
+}
+
+func TestStringToType(t *testing.T) {
+	str1 := `[item1,item2]`
+
+	res1 := safestrings.ToType(str1)
+
+	if reflect.TypeOf(res1) != reflect.TypeFor[[]string]() {
+		t.Error("Expected: ", str1, " == []string", "; Got: ", str1, " == ", reflect.TypeOf(res1))
+	}
+
+	str2 := `1`
+
+	res2 := safestrings.ToType(str2)
+
+	if reflect.TypeOf(res2) != reflect.TypeFor[int]() {
+		t.Error("Expected: ", str2, " == int", "; Got: ", str2, " == ", reflect.TypeOf(res2))
+	}
+
+	str3 := `{ "key": "value" }`
+
+	res3 := safestrings.ToType(str3)
+
+	if reflect.TypeOf(res3) != reflect.TypeFor[map[string]any]() {
+		t.Error("Expected: ", str3, " == map[string]any", "; Got: ", str3, " == ", reflect.TypeOf(res3))
+	}
+}

utils/config/config.go

@@ -8,8 +8,8 @@ import (
 	"strings"
 
 	middlewares "github.com/codeshelldev/secured-signal-api/internals/proxy/middlewares"
-	utils "github.com/codeshelldev/secured-signal-api/utils"
 	log "github.com/codeshelldev/secured-signal-api/utils/logger"
+	"github.com/codeshelldev/secured-signal-api/utils/safestrings"
 
 	"github.com/knadh/koanf/parsers/yaml"
 	"github.com/knadh/koanf/providers/confmap"
@@ -178,28 +178,5 @@ func normalizeKeys(config *koanf.Koanf) {
 func normalizeEnv(key string, value string) (string, any) {
 	key = strings.ToLower(strings.ReplaceAll(key, "__", "."))
 
-	if strings.HasPrefix(value, "{") || strings.HasPrefix(value, "[") {
-		data, err := utils.GetJsonSafe[any](value)
-
-		if data != nil && err == nil {
-			return key, data
-		}
-	}
-
-	if strings.Contains(value, ",") {
-		items := utils.StringToArray(value)
-		
-		return key, items
-	}
-
-	// Treat `+` prefixed Values as strings
-	if !strings.HasPrefix(value, "+") {
-		intValue, intErr := strconv.Atoi(value)
-
-		if intErr == nil {
-			return key, intValue
-		}
-	}
-
-	return key, value
+	return key, safestrings.ToType(value)
 }

utils/query/query.go

@@ -1,9 +1,9 @@
 package query
 
 import (
-	"regexp"
-	"strconv"
 	"strings"
+
+	"github.com/codeshelldev/secured-signal-api/utils/safestrings"
 )
 
 func ParseRawQuery(raw string) map[string][]string {
@@ -30,55 +30,10 @@ func ParseRawQuery(raw string) map[string][]string {
 	return result
 }
 
-func tryParseInt(str string) (int, bool) {
-	isInt, err := regexp.MatchString(`^\d+$`, str)
-
-	if isInt && err == nil {
-		intValue, err := strconv.Atoi(str)
-
-		if err == nil {
-			return intValue, true
-		}
-	}
-
-	return 0, false
-}
-
 func ParseTypedQueryValues(values []string) any {
-	var result any
-
-	raw := values[0]
-
-	intValue, isInt := tryParseInt(raw)
+	raw := values[len(values)-1]
 
-	if strings.Contains(raw, ",") || (strings.Contains(raw, "[") && strings.Contains(raw, "]")) {
-		if strings.Contains(raw, "[") && strings.Contains(raw, "]") {
-			escapedStr := strings.ReplaceAll(raw, "[", "")
-			escapedStr = strings.ReplaceAll(escapedStr, "]", "")
-			raw = escapedStr
-		}
-
-		parts := strings.Split(raw, ",")
-
-		var list []any
-
-		for _, part := range parts {
-			_intValue, _isInt := tryParseInt(part)
-
-			if _isInt {
-				list = append(list, _intValue)
-			} else {
-				list = append(list, part)
-			}
-		}
-		result = list
-	} else if isInt {
-		result = intValue
-	} else {
-		result = raw
-	}
-
-	return result
+	return safestrings.ToType(raw)
 }
 
 func ParseTypedQuery(query string, matchPrefix string) (map[string]any) {