utils.go

package main

import (
	"encoding/json"
	"fmt"
	"log"
	"net/http"
	"os"
	"os/signal"
	"regexp"
	"strings"
	"syscall"
	"unicode"

	"github.com/elgs/gosqlcrud"
)

// valuesToMap - convert url.Values to map[string]any
func valuesToMap(keyLowerCase bool, nullValue any, values ...map[string][]string) map[string]any {
	ret := map[string]any{}
	for _, vs := range values {
		for k, v := range vs {
			var value any
			if len(v) == 0 {
				value = nil
			} else if len(v) >= 1 {
				value = v[0]
				if value == nullValue {
					value = nil
				}
			}
			if keyLowerCase {
				ret[strings.ToLower(k)] = value
			} else {
				ret[k] = value
			}
		}
	}
	return ret
}

func Hook(clean func()) {
	sigs := make(chan os.Signal, 1)
	done := make(chan bool, 1)
	signal.Notify(sigs, syscall.SIGINT, syscall.SIGTERM)

	go func() {
		<-sigs
		if clean != nil {
			clean()
		}
		done <- true
	}()
	<-done
}

func SqlNormalize(sql *string) {
	*sql = strings.TrimSpace(*sql)
	var ret string
	lines := strings.Split(*sql, "\n")
	for _, line := range lines {
		lineTrimmed := strings.TrimSpace(line)
		if lineTrimmed != "" && !strings.HasPrefix(lineTrimmed, "--") {
			ret += line + "\n"
		}
	}
	*sql = ret
}

var reSqlLabel = regexp.MustCompile(`(?i)^\-\-\s*@label\s*\:\s*(.+)\s*`)

func SplitSqlLabel(sqlString string) (label string, s string) {
	sqlString = strings.TrimSpace(sqlString) + "\n"
	labelAndSql := strings.SplitN(sqlString, "\n", 2)
	labelPart := labelAndSql[0]
	sqlPart := labelAndSql[1]
	m := reSqlLabel.FindStringSubmatch(labelPart)
	if len(m) >= 2 {
		SqlNormalize(&sqlPart)
		return strings.TrimSpace(m[1]), strings.TrimSpace(sqlPart)
	}
	SqlNormalize(&sqlString)
	return "", strings.TrimSpace(sqlString)
}

// buildOrderBy accepts only "column [asc|desc]" terms, comma separated. The
// order_by value can come from the request, so anything else is rejected
// instead of being interpolated into the SQL.
func buildOrderBy(orderBy string) (string, error) {
	parts := strings.Split(orderBy, ",")
	for i, part := range parts {
		fields := strings.Fields(strings.TrimSpace(part))
		if len(fields) == 0 || len(fields) > 2 || !gosqlcrud.ValidIdentifier(fields[0]) {
			return "", fmt.Errorf("bad order_by %q", orderBy)
		}
		if len(fields) == 2 {
			direction := strings.ToUpper(fields[1])
			if direction != "ASC" && direction != "DESC" {
				return "", fmt.Errorf("bad order_by %q", orderBy)
			}
			fields[1] = direction
		}
		parts[i] = strings.Join(fields, " ")
	}
	return "ORDER BY " + strings.Join(parts, ", "), nil
}

func IsQuery(sql string) bool {
	sqlUpper := strings.ToUpper(strings.TrimSpace(sql))
	return strings.HasPrefix(sqlUpper, "SELECT") ||
		strings.HasPrefix(sqlUpper, "SHOW") ||
		strings.HasPrefix(sqlUpper, "DESCRIBE") ||
		strings.HasPrefix(sqlUpper, "EXPLAIN") ||
		strings.HasPrefix(sqlUpper, "PRAGMA") ||
		strings.HasPrefix(sqlUpper, "WITH")
}

func ShouldExport(sql string) bool {
	if len(sql) == 0 {
		return false
	}
	if !unicode.IsLetter([]rune(sql)[0]) {
		return false
	}
	return strings.ToUpper(sql[0:1]) == sql[0:1]
}

func ExtractIPAddressFromHost(host string) string {
	sepIndex := strings.LastIndex(host, ":")
	if sepIndex < 0 {
		return strings.ReplaceAll(strings.ReplaceAll(host, "[", ""), "]", "")
	}
	ip := host[0:sepIndex]
	ip = strings.ReplaceAll(strings.ReplaceAll(ip, "[", ""), "]", "")
	return ip
}

func GetMetaDataFromRequest(key string, r *http.Request) string {
	if key == "host" {
		return r.Host
	} else if key == "remote_addr" {
		return ExtractIPAddressFromHost(r.RemoteAddr)
	} else if key == "method" {
		return r.Method
	} else if key == "path" {
		return r.URL.Path
	} else if key == "query" {
		return r.URL.RawQuery
	} else if key == "user_agent" {
		return r.UserAgent()
	} else if key == "referer" {
		return r.Referer()
	}
	return r.Header.Get(key)
}

func ArrayOfStructsToArrayOfPointersOfStructs[T any](a []T) []*T {
	b := make([]*T, len(a))
	for i := range a {
		b[i] = &a[i]
	}
	return b
}

func writeJSONError(w http.ResponseWriter, statusCode int, msg string) {
	if statusCode >= 500 {
		log.Printf("ERROR %d: %s\n", statusCode, msg)
	}
	w.WriteHeader(statusCode)
	resp, _ := json.Marshal(map[string]string{"error": msg})
	w.Write(resp)
}

func Contains[T comparable](s []T, e T) bool {
	for _, v := range s {
		if v == e {
			return true
		}
	}
	return false
}