feat: improve templating

.github/templates/README.template.md

@@ -123,7 +123,15 @@ curl -X POST -H "Content-Type: application/json" -H "Authorization: Bearer API_T
 
 If you are not comfortable / don't want to hardcode your Number for example and/or Recipients in you, may use **Placeholders** in your Request.
 
-You can use [**Variable**](#variables) `{{.NUMBER}}` Placeholders and **Body** Placeholders `{{@data.key}}`.
+**How to use:**
+
+| Type                   | Example             | Note             |
+| :--------------------- | :------------------ | :--------------- |
+| Body                   | `{{@data.key}}`     |                  |
+| Header                 | `{{#Content_Type}}` | `-` becomes `_`  |
+| [Variable](#variables) | `{{.VAR}}`          | always uppercase |
+
+**Where to use:**
 
 | Type  | Example                                                          |
 | :---- | :--------------------------------------------------------------- |
@@ -220,6 +228,47 @@ If you are using Environment Variables as an example you won't be able to specif
 > If you have a string that should not be turned into any other type, then you will need to escape all Type Denotations, `[]` or `{}` (also `-`) with a `\` **Backslash** (or Double Backslash).
 > An **Odd** number of **Backslashes** **escape** the character in front of them and an **Even** number leave the character **as-is**.
 
+### Templating
+
+Secured Signal API uses Golang's [Standard Templating Library](https://pkg.go.dev/text/template).
+This means that any valid Go template string will also work in Secured Signal API.
+
+Go's templating library is used in the following features:
+
+- [Message Templates](#message-templates)
+- [Placeholders](#placeholders)
+
+This makes advanced [Message Templates](#message-templates) like this one possible:
+
+```yaml
+settings:
+    messageTemplate: |
+    {{- $greeting := "Hello" -}}
+    {{ $greeting }}, {{ @name }}!
+    {{ if @age -}}
+    You are {{ @age }} years old.
+    {{- else -}}
+    Age unknown.
+    {{- end }}
+    Your friends:
+    {{- range @friends }}
+    - {{ . }}
+    {{- else }}
+    You have no friends.
+    {{- end }}
+    Profile details:
+    {{- range $key, $value := @profile }}
+    - {{ $key }}: {{ $value }}
+    {{- end }}
+    {{ define "footer" -}}
+    This is the footer for {{ @name }}.
+    {{- end }}
+    {{ template "footer" . -}}
+    ------------------------------------
+    Content-Type: {{ #Content_Type }}
+    Redacted Auth Header: {{ #Authorization }}
+```
+
 ### API Token(s)
 
 During Authentication Secured Signal API will try to match the given Token against the list of Tokens inside of these Variables.
@@ -301,7 +350,8 @@ settings:
     Sent with Secured Signal API.
 ```
 
-Use `{{@data.key}}` to reference Body Keys and `{{.KEY}}` for Variables.
+Message Templates support [Standard Golang Templating](#templating).
+Use `@data.key` to reference Body Keys, `#Content_Type` for Headers and `.KEY` for Variables.
 
 ### Data Aliases
 

internals/proxy/middlewares/message.go

@@ -46,7 +46,9 @@ func (data MessageMiddleware) Use() http.Handler {
 			bodyData = body.Data
 
 			if messageTemplate != "" {
-				newData, err := TemplateMessage(messageTemplate, bodyData, variables)
+				headerData := request.GetReqHeaders(req)
+
+				newData, err := TemplateMessage(messageTemplate, bodyData, headerData, variables)
 
 				if err != nil {
 					log.Error("Error Templating Message: ", err.Error())
@@ -83,13 +85,13 @@ func (data MessageMiddleware) Use() http.Handler {
 	})
 }
 
-func TemplateMessage(template string, data map[string]any, VARIABLES map[string]any) (map[string]any, error) {
-	data["message_template"] = template
+func TemplateMessage(template string, bodyData map[string]any, headerData map[string]any, variables map[string]any) (map[string]any, error) {
+	bodyData["message_template"] = template
 
-	data, _, err := TemplateBody(data, VARIABLES)
+	data, _, err := TemplateBody(bodyData, headerData, variables)
 
 	if err != nil || data == nil {
-		return data, err
+		return bodyData, err
 	}
 
 	data["message"] = data["message_template"]

internals/proxy/middlewares/template.go

@@ -3,10 +3,12 @@ package middlewares
 import (
 	"bytes"
 	"io"
+	"maps"
 	"net/http"
 	"net/url"
 	"regexp"
 	"strconv"
+	"strings"
 
 	jsonutils "github.com/codeshelldev/secured-signal-api/utils/jsonutils"
 	log "github.com/codeshelldev/secured-signal-api/utils/logger"
@@ -42,7 +44,9 @@ func (data TemplateMiddleware) Use() http.Handler {
 		if !body.Empty {
 			var modified bool
 
-			bodyData, modified, err = TemplateBody(body.Data, variables)
+			headerData := request.GetReqHeaders(req)
+
+			bodyData, modified, err = TemplateBody(body.Data, headerData, variables)
 
 			if err != nil {
 				log.Error("Error Templating JSON: ", err.Error())
@@ -105,19 +109,23 @@ func (data TemplateMiddleware) Use() http.Handler {
 	})
 }
 
-func TemplateBody(data map[string]any, VARIABLES map[string]any) (map[string]any, bool, error) {
-	var modified bool
-
+func normalizeData(fromPrefix, toPrefix string, data map[string]any) (map[string]any, error) {
 	jsonStr := jsonutils.ToJson(data)
 
 	if jsonStr != "" {
-		re, err := regexp.Compile(`{{\s*\@([a-zA-Z0-9_.]+)\s*}}`)
+		toVar, err := templating.TransformTemplateKeys(jsonStr, fromPrefix, func(re *regexp.Regexp, match string) string {
+			return re.ReplaceAllStringFunc(match, func(varMatch string) string {
+				varName := re.ReplaceAllString(varMatch, "$1")
+
+				return "." + toPrefix + varName
+			})
+		})
 
 		if err != nil {
-			return data, false, err
+			return data, err
 		}
 
-		jsonStr = re.ReplaceAllString(jsonStr, "{{.$1}}")
+		jsonStr = toVar
 
 		normalizedData, err := jsonutils.GetJsonSafe[map[string]any](jsonStr)
 
@@ -126,16 +134,78 @@ func TemplateBody(data map[string]any, VARIABLES map[string]any) (map[string]any
 		}
 	}
 
-	templatedData, err := templating.RenderJSON("body", data, VARIABLES)
+	return data, nil
+}
+
+func prefixData(prefix string, data map[string]any) (map[string]any) {
+	res := map[string]any{}
+
+	for key, value := range data {
+		res[prefix + key] = value
+	}
+
+	return res
+}
+
+func cleanHeaders(headers map[string]any) map[string]any {
+	cleanedHeaders := map[string]any{}
+
+	for key, value := range headers {
+		cleanedKey := strings.ReplaceAll(key, "-", "_")
+
+		cleanedHeaders[cleanedKey] = value
+	}
+
+	authHeader, ok := cleanedHeaders["Authorization"].([]string)
+
+	if !ok {
+		authHeader = []string{"UNKNOWN REDACTED"}
+	}
+
+	cleanedHeaders["Authorization"] = strings.Split(authHeader[0], ` `)[0] + " REDACTED"
+
+	return cleanedHeaders
+}
+
+func TemplateBody(body map[string]any, headers map[string]any, VARIABLES map[string]any) (map[string]any, bool, error) {
+	var modified bool
+
+	headers = cleanHeaders(headers)
+
+	// Normalize #Var and @Var to .header_key_Var and .body_key_Var
+	normalizedBody, err := normalizeData("@", "body_key_", body)
+
+	if err != nil {
+		return body, false, err
+	}
+
+	normalizedBody, err = normalizeData("#", "header_key_", normalizedBody)
 
 	if err != nil {
-		return data, false, err
+		return body, false, err
 	}
 
-	beforeStr := jsonutils.ToJson(templatedData)
-	afterStr := jsonutils.ToJson(data)
+	// Prefix Body Data with body_key_
+	prefixedBody := prefixData("body_key_", normalizedBody)
+
+	// Prefix Header Data with header_key_
+	prefixedHeaders := prefixData("header_key_", headers)
+
+	variables := VARIABLES
+
+	maps.Copy(variables, prefixedBody)
+	maps.Copy(variables, prefixedHeaders)
 
-	modified = beforeStr == afterStr
+	templatedData, err := templating.RenderJSON("body", normalizedBody, variables)
+
+	if err != nil {
+		return body, false, err
+	}
+
+	beforeStr := jsonutils.ToJson(body)
+	afterStr := jsonutils.ToJson(templatedData)
+
+	modified = beforeStr != afterStr
 
 	return templatedData, modified, nil
 }
@@ -184,4 +254,4 @@ func TemplateQuery(reqUrl *url.URL, data map[string]any, VARIABLES any) (string,
 	reqRawQuery := originalQueryData.Encode()
 
 	return reqRawQuery, data, modified, nil
-}
+}

tests/json_test.go

@@ -44,10 +44,10 @@ func TestJsonTemplating(t *testing.T) {
 		"key2": 4,
 	}
 
-	got, err := templating.RenderJSONTemplate("json", data, variables)
+	got, err := templating.RenderDataKeyTemplateRecursive("", data, variables)
 
 	if err != nil {
-		t.Error("Error Templating JSON: ", err.Error())
+		t.Error("Error Templating JSON:\n", err.Error())
 	}
 
 	expectedStr := jsonutils.ToJson(expected)

utils/request/request.go

@@ -95,6 +95,16 @@ func GetBody(req *http.Request) ([]byte, error) {
 	return bodyBytes, nil
 }
 
+func GetReqHeaders(req *http.Request) (map[string]any) {
+	data := map[string]any{}
+
+	for key, value := range req.Header {
+		data[key] = value
+	}
+
+	return data
+}
+
 func GetReqBody(w http.ResponseWriter, req *http.Request) (Body, error) {
 	bytes, err := GetBody(req)
 

utils/stringutils/stringutils.go

@@ -1,4 +1,4 @@
-package safestrings
+package stringutils
 
 import (
 	"regexp"