Merge pull request #31 from pedramktb/feature/postgres-errors-refactor

feat: refactored packages, added postgres with test containers, added custom types and taggederror

Author: pedramktb

.github/workflows/_test.yml

@@ -10,7 +10,7 @@ jobs:
       - uses: actions/checkout@v4
       - uses: actions/setup-go@v5
         with:
-          go-version: "1.23.5"
+          go-version: "1.24.2"
 
       - name: Install Taskfile
         run: go install github.com/go-task/task/v3/cmd/task@latest

pkg/auth/ed25519.go auth/ed25519.gopkg/auth/ed25519.go renamed to auth/ed25519.go

@@ -1,33 +1,56 @@
 package env
 
 import (
+	"errors"
 	"os"
 	"strconv"
+)
+
+type Environment string
 
-	"github.com/joho/godotenv"
+const (
+	EnvironmentProd    Environment = "prod"
+	EnvironmentStaging Environment = "staging"
+	EnvironmentDev     Environment = "dev"
+	EnvironmentLocal   Environment = ""
 )
 
-func init() {
-	_ = godotenv.Load(".env")
+func (e Environment) String() string {
+	if e == EnvironmentLocal {
+		return "local"
+	} else {
+		return string(e)
+	}
 }
 
-// IsDebug returns true if the DEBUG environment variable is set to true
-func IsDebug() bool {
-	return GetWithFallback("DEBUG", false)
+var env Environment
+var envSet bool
+
+func SetEnvironment(e Environment) {
+	env = e
+	envSet = true
+}
+
+func GetEnvironment() Environment {
+	if envSet {
+		return env
+	}
+	e, _ := GetWithFallback("ENVIRONMENT", string(EnvironmentLocal))
+	return Environment(e)
 }
 
-// GetOrFail returns the value of the environment variable or panics if it is not set
-func GetOrFail[
+// GetOrFail returns the value of the environment variable or returns an error if it is not set
+func GetOrFail[ //NOSONAR
 	T string |
 		bool |
 		uintptr |
 		int | int64 | int32 | int16 | int8 |
 		uint | uint64 | uint32 | uint16 | uint8 |
 		float64 | float32 |
-		complex128 | complex64](env string) T {
+		complex128 | complex64](env string) (T, error) {
 	str := os.Getenv(env)
 	if str == "" {
-		panic("missing env variable: " + env)
+		return *new(T), errors.New("missing env variable: " + env)
 	}
 
 	var val any
@@ -38,104 +61,104 @@ func GetOrFail[
 	case bool:
 		b, err := strconv.ParseBool(str)
 		if err != nil {
-			panic("invalid bool: " + env)
+			return *new(T), errors.New("invalid bool: " + env)
 		}
 		val = b
 	case uintptr:
 		u64, err := strconv.ParseUint(str, 10, 0)
 		if err != nil {
-			panic("invalid uintptr: " + env)
+			return *new(T), errors.New("invalid uintptr: " + env)
 		}
 		val = uintptr(u64)
 	case int:
 		i64, err := strconv.ParseInt(str, 10, 0)
 		if err != nil {
-			panic("invalid int: " + env)
+			return *new(T), errors.New("invalid int: " + env)
 		}
 		val = int(i64)
 	case int64:
 		i64, err := strconv.ParseInt(str, 10, 64)
 		if err != nil {
-			panic("invalid int64: " + env)
+			return *new(T), errors.New("invalid int64: " + env)
 		}
 		val = i64
 	case int32:
 		i64, err := strconv.ParseInt(str, 10, 32)
 		if err != nil {
-			panic("invalid int32: " + env)
+			return *new(T), errors.New("invalid int32: " + env)
 		}
 		val = int32(i64)
 	case int16:
 		i64, err := strconv.ParseInt(str, 10, 16)
 		if err != nil {
-			panic("invalid int16: " + env)
+			return *new(T), errors.New("invalid int16: " + env)
 		}
 		val = int16(i64)
 	case int8:
 		i64, err := strconv.ParseInt(str, 10, 8)
 		if err != nil {
-			panic("invalid int8: " + env)
+			return *new(T), errors.New("invalid int8: " + env)
 		}
 		val = int8(i64)
 	case uint:
 		i64, err := strconv.ParseUint(str, 10, 0)
 		if err != nil {
-			panic("invalid uint: " + env)
+			return *new(T), errors.New("invalid uint: " + env)
 		}
 		val = uint(i64)
 	case uint64:
 		i64, err := strconv.ParseUint(str, 10, 64)
 		if err != nil {
-			panic("invalid uint64: " + env)
+			return *new(T), errors.New("invalid uint64: " + env)
 		}
 		val = i64
 	case uint32:
 		i64, err := strconv.ParseUint(str, 10, 32)
 		if err != nil {
-			panic("invalid uint32: " + env)
+			return *new(T), errors.New("invalid uint32: " + env)
 		}
 		val = uint32(i64)
 	case uint16:
 		i64, err := strconv.ParseUint(str, 10, 16)
 		if err != nil {
-			panic("invalid uint16: " + env)
+			return *new(T), errors.New("invalid uint16: " + env)
 		}
 		val = uint16(i64)
 	case uint8:
 		i64, err := strconv.ParseUint(str, 10, 8)
 		if err != nil {
-			panic("invalid uint8: " + env)
+			return *new(T), errors.New("invalid uint8: " + env)
 		}
 		val = uint8(i64)
 	case float64:
 		f64, err := strconv.ParseFloat(str, 64)
 		if err != nil {
-			panic("invalid float64: " + env)
+			return *new(T), errors.New("invalid float64: " + env)
 		}
 		val = f64
 	case float32:
 		f64, err := strconv.ParseFloat(str, 32)
 		if err != nil {
-			panic("invalid float32: " + env)
+			return *new(T), errors.New("invalid float32: " + env)
 		}
 		val = float32(f64)
 	case complex128:
 		c128, err := strconv.ParseComplex(str, 128)
 		if err != nil {
-			panic("invalid complex128: " + env)
+			return *new(T), errors.New("invalid complex128: " + env)
 		}
 		val = c128
 	case complex64:
 		c128, err := strconv.ParseComplex(str, 64)
 		if err != nil {
-			panic("invalid complex64: " + env)
+			return *new(T), errors.New("invalid complex64: " + env)
 		}
 		val = complex64(c128)
 	default:
-		panic("unsupported type")
+		return *new(T), errors.New("unsupported type")
 	}
 
-	return val.(T)
+	return val.(T), nil
 }
 
 // GetWithFallback returns the value of the environment variable or the fallback value if it is not set
@@ -146,10 +169,10 @@ func GetWithFallback[
 		int | int64 | int32 | int16 | int8 |
 		uint | uint64 | uint32 | uint16 | uint8 |
 		float64 | float32 |
-		complex128 | complex64](env string, fallback T) T {
+		complex128 | complex64](env string, fallback T) (T, error) {
 	str := os.Getenv(env)
 	if str == "" {
-		return fallback
+		return fallback, nil
 	}
 
 	return GetOrFail[T](env)

pkg/env/env.go env/env.gopkg/env/env.go renamed to env/env.go

@@ -11,6 +11,7 @@ func Test_GetOrFail(t *testing.T) {
 		key      string
 		value    string
 		expected any
+		wantErr  bool
 	}{
 		{
 			name:     "rune",
@@ -132,47 +133,53 @@ func Test_GetOrFail(t *testing.T) {
 		t.Run(tt.name, func(t *testing.T) {
 			os.Setenv(tt.key, tt.value)
 			var got any
+			var err error
 			switch tt.expected.(type) {
 			case string:
-				got = GetOrFail[string](tt.key)
+				got, err = GetOrFail[string](tt.key)
 			case bool:
-				got = GetOrFail[bool](tt.key)
+				got, err = GetOrFail[bool](tt.key)
 			case uintptr:
-				got = GetOrFail[uintptr](tt.key)
+				got, err = GetOrFail[uintptr](tt.key)
 			case int:
-				got = GetOrFail[int](tt.key)
+				got, err = GetOrFail[int](tt.key)
 			case int64:
-				got = GetOrFail[int64](tt.key)
+				got, err = GetOrFail[int64](tt.key)
 			case int32:
-				got = GetOrFail[int32](tt.key)
+				got, err = GetOrFail[int32](tt.key)
 			case int16:
-				got = GetOrFail[int16](tt.key)
+				got, err = GetOrFail[int16](tt.key)
 			case int8:
-				got = GetOrFail[int8](tt.key)
+				got, err = GetOrFail[int8](tt.key)
 			case uint:
-				got = GetOrFail[uint](tt.key)
+				got, err = GetOrFail[uint](tt.key)
 			case uint64:
-				got = GetOrFail[uint64](tt.key)
+				got, err = GetOrFail[uint64](tt.key)
 			case uint32:
-				got = GetOrFail[uint32](tt.key)
+				got, err = GetOrFail[uint32](tt.key)
 			case uint16:
-				got = GetOrFail[uint16](tt.key)
+				got, err = GetOrFail[uint16](tt.key)
 			case uint8:
-				got = GetOrFail[uint8](tt.key)
+				got, err = GetOrFail[uint8](tt.key)
 			case float64:
-				got = GetOrFail[float64](tt.key)
+				got, err = GetOrFail[float64](tt.key)
 			case float32:
-				got = GetOrFail[float32](tt.key)
+				got, err = GetOrFail[float32](tt.key)
 			case complex128:
-				got = GetOrFail[complex128](tt.key)
+				got, err = GetOrFail[complex128](tt.key)
 			case complex64:
-				got = GetOrFail[complex64](tt.key)
+				got, err = GetOrFail[complex64](tt.key)
 			default:
 				t.Fatalf("unsupported type: %T", tt.expected)
 			}
 			if got != tt.expected {
 				t.Errorf("got %v, expected %v", got, tt.expected)
 			}
+			if err != nil && !tt.wantErr {
+				t.Errorf("unexpected error: %v", err)
+			} else if err == nil && tt.wantErr {
+				t.Errorf("expected error but got none")
+			}
 		})
 	}
 }

pkg/env/env_test.go env/env_test.gopkg/env/env_test.go renamed to env/env_test.go

@@ -0,0 +1,18 @@
+package env
+
+import (
+	"os"
+	"strings"
+)
+
+// RemovePrefix resets environment variables with a certain prefix without the prefix
+// (e.g. added by the cloud provider)
+func RemovePrefix(prefix string) {
+	for _, env := range os.Environ() {
+		pairs := strings.SplitN(env, "=", 2)
+		if strings.HasPrefix(pairs[0], prefix) {
+			newKey := strings.TrimPrefix(pairs[0], prefix)
+			os.Setenv(newKey, pairs[1])
+		}
+	}
+}

env/prefix.go

@@ -19,7 +19,7 @@ const charset = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
 func randomString(n int) string {
 	sb := strings.Builder{}
 	sb.Grow(n)
-	for i := 0; i < n; i++ {
+	for range n {
 		sb.WriteByte(charset[unsafeRand.Intn(len(charset))])
 	}
 	return sb.String()