chore: quick update fix/version at 2025-09-24 23:16:29

Author: kooksee

config/envs.go

@@ -20,6 +20,8 @@ type EnvSpec struct {
 
 func initEnv(envMap EnvSpecMap) {
 	for name, cfg := range envMap {
+		cfg.Name = name
+		
 		envData := strings.TrimSpace(strutil.FirstNotEmpty(env.Get(name), cfg.Value, cfg.Default))
 		if cfg.Required && envData == "" {
 			panic("env " + cfg.Name + " is required")

env/env.go

@@ -9,17 +9,25 @@ import (
 
 	"github.com/a8m/envsubst"
 	"github.com/joho/godotenv"
+	"github.com/rs/zerolog"
 	"github.com/samber/lo"
 
 	"github.com/pubgo/funk/assert"
+	"github.com/pubgo/funk/log/logfields"
 	"github.com/pubgo/funk/pathutil"
 	"github.com/pubgo/funk/v2/result"
 )
 
 func Set(key, value string) result.Error {
-	return result.ErrOf(os.Setenv(KeyHandler(key), value))
+	return result.ErrOf(os.Setenv(keyHandler(key), value)).Log(func(e *zerolog.Event) {
+		e.Str("key", key)
+		e.Str("value", value)
+		e.Str(logfields.Msg, "env_set_error")
+	})
 }
 
+func MustSet(key, value string) { Set(key, value).Must() }
+
 func GetDefault(name string, defaultVal string) string {
 	val := Get(name)
 	return lo.If(val != "", val).Else(defaultVal)
@@ -28,29 +36,29 @@ func GetDefault(name string, defaultVal string) string {
 func Get(names ...string) string {
 	var val string
 	GetVal(&val, names...)
-	return trim(val)
+	return val
 }
 
 func MustGet(names ...string) string {
 	var val string
 	GetVal(&val, names...)
 	assert.If(val == "", "env not found, names=%q", names)
-	return trim(val)
+	return val
 }
 
 func GetVal(val *string, names ...string) {
 	for _, name := range names {
 		env, ok := Lookup(name)
 		env = trim(env)
 		if ok && env != "" {
-			*val = trim(env)
+			*val = env
 			break
 		}
 	}
 }
 
 func GetBoolVal(val *bool, names ...string) {
-	dt := trim(Get(names...))
+	dt := Get(names...)
 	if dt == "" {
 		return
 	}
@@ -65,7 +73,7 @@ func GetBoolVal(val *bool, names ...string) {
 }
 
 func GetIntVal(val *int, names ...string) {
-	dt := trim(Get(names...))
+	dt := Get(names...)
 	if dt == "" {
 		return
 	}
@@ -80,7 +88,7 @@ func GetIntVal(val *int, names ...string) {
 }
 
 func GetFloatVal(val *float64, names ...string) {
-	dt := trim(Get(names...))
+	dt := Get(names...)
 	if dt == "" {
 		return
 	}
@@ -94,37 +102,77 @@ func GetFloatVal(val *float64, names ...string) {
 	*val = v
 }
 
-func Lookup(key string) (string, bool) {
-	return os.LookupEnv(Key(key))
-}
+func Lookup(key string) (string, bool) { return os.LookupEnv(keyHandler(key)) }
 
 func Delete(key string) result.Error {
-	return result.ErrOf(os.Unsetenv(Key(key)))
+	return result.ErrOf(os.Unsetenv(keyHandler(key))).Log(func(e *zerolog.Event) {
+		e.Str("key", key)
+		e.Str(logfields.Msg, "env_delete_error")
+	})
 }
 
 func Expand(value string) result.Result[string] {
-	return result.Wrap(envsubst.String(value))
+	return result.Wrap(envsubst.String(value)).Log(func(e *zerolog.Event) {
+		e.Str("value", value)
+		e.Str(logfields.Msg, "env_expand_error")
+	})
 }
 
 func Map() map[string]string {
 	data := make(map[string]string, len(os.Environ()))
 	for _, env := range os.Environ() {
 		envs := strings.SplitN(env, "=", 2)
-		data[envs[0]] = envs[1]
+		if len(envs) != 2 {
+			continue
+		}
+
+		data[keyHandler(envs[0])] = envs[1]
 	}
 	return data
 }
 
 func Key(key string) string {
-	return KeyHandler(key)
+	return keyHandler(key)
 }
 
 func LoadFiles(files ...string) (r result.Error) {
 	files = lo.Filter(files, func(item string, index int) bool { return pathutil.IsExist(item) })
-	if result.Catch(&r, godotenv.Overload(files...)) {
+	if len(files) == 0 {
 		return
 	}
 
+	for _, file := range files {
+		data := result.Wrap(os.ReadFile(file)).Unwrap(&r)
+		if r.IsErr() {
+			return
+		}
+
+		dataMap := result.Wrap(godotenv.UnmarshalBytes(data)).Unwrap(&r)
+		if r.IsErr() {
+			return
+		}
+
+		for k, v := range dataMap {
+			if k == "" || v == "" {
+				continue
+			}
+
+			if Set(k, v).Catch(&r) {
+				return
+			}
+		}
+	}
+
 	loadEnv()
 	return
 }
+
+// Normalize a-b=>a_b, a.b=>a_b, a/b=>a_b
+func Normalize(key string) (string, bool) {
+	key = trim(key)
+	if key == "" || strings.HasPrefix(key, "_") || strings.HasPrefix(key, "=") {
+		return key, false
+	}
+
+	return keyHandler(key), true
+}

env/reload.go

@@ -6,6 +6,7 @@ import (
 	"os"
 	"strings"
 
+	"github.com/pubgo/funk/assert"
 	"github.com/pubgo/funk/log/logfields"
 )
 
@@ -22,41 +23,29 @@ func Init() {
 // 环境变量处理, key转大写, 同时把`-./`转换为`_`
 // a-b=>a_b, a.b=>a_b, a/b=>a_b
 func loadEnv() {
-	envPrefix := getEnvPrefix()
-
-	logger := slog.With(
-		slog.String(logfields.Module, "env"),
-		slog.String(logfields.Operation, "reload_env"),
-	)
-	logger.Info("reload env", slog.Any("env_prefix", map[string]any{"key": PrefixKey, "value": envPrefix}))
+	logger := slog.With(slog.String(logfields.Module, "env"), slog.String(logfields.Operation, "reload_env"))
+	logger.Info("reload env")
 
 	for _, env := range os.Environ() {
 		kvs := strings.SplitN(env, "=", 2)
 		if len(kvs) != 2 {
-			logger.Error("split env error")
-			continue
-		}
-
-		rawEnvKey := trim(kvs[0])
-		if rawEnvKey == "" ||
-			strings.HasPrefix(rawEnvKey, "_") ||
-			strings.HasPrefix(rawEnvKey, "=") ||
-			!hasEnvPrefix(rawEnvKey, envPrefix) {
-			logger.Warn(fmt.Sprintf("unset env, key=%s", rawEnvKey))
-			_ = os.Unsetenv(rawEnvKey)
+			logger.Error("split env error", slog.String("env", env))
 			continue
 		}
 
-		key, ok := Normalize(rawEnvKey)
+		oldKey := trim(kvs[0])
+		newKey, ok := Normalize(oldKey)
 		if ok {
-			if key == rawEnvKey {
+			if newKey == oldKey {
 				continue
 			}
 
-			setOk := os.Setenv(key, kvs[1]) == nil
-			logger.Info(fmt.Sprintf("reset env, old_key=%s new_key=%s set_ok=%v", rawEnvKey, key, setOk))
+			assert.Exit(os.Unsetenv(oldKey))
+			assert.Exit(os.Setenv(newKey, kvs[1]))
+			logger.Info(fmt.Sprintf("reset env, old_key=%s new_key=%s", oldKey, newKey))
 		} else {
-			_ = os.Unsetenv(rawEnvKey)
+			logger.Warn(fmt.Sprintf("unset env, key=%s", oldKey))
+			assert.Exit(os.Unsetenv(oldKey))
 		}
 	}
 }

env/util.go

@@ -1,26 +1,11 @@
 package env
 
 import (
-	"os"
 	"strings"
 
 	"github.com/ettle/strcase"
 )
 
-const PrefixKey = "ENV_PREFIX"
-
-func hasEnvPrefix(key string, prefix string) bool {
-	return strings.HasPrefix(strings.ToUpper(key), strings.ToUpper(prefix))
-}
-
-func getEnvPrefix() string {
-	prefix := strings.TrimSpace(os.Getenv(PrefixKey))
-	if prefix != "" {
-		prefix = strings.ReplaceAll(prefix+"_", "__", "_")
-	}
-	return strings.ToUpper(prefix)
-}
-
 var trim = strings.TrimSpace
 var replacer = strcase.NewCaser(
 	true,
@@ -32,21 +17,7 @@ var replacer = strcase.NewCaser(
 		strcase.PreserveNumberFormatting,
 	))
 
-func KeyHandler(key string) string {
-	key = strings.ToUpper(replacer.ToSNAKE(key))
-	envPrefix := getEnvPrefix()
-	if envPrefix != "" {
-		key = envPrefix + "_" + strings.TrimPrefix(key, envPrefix)
-	}
-	return strings.ToUpper(trim(strings.ReplaceAll(key, "__", "_")))
-}
-
-// Normalize a-b=>a_b, a.b=>a_b, a/b=>a_b
-func Normalize(key string) (string, bool) {
-	key = trim(key)
-	if key == "" || strings.HasPrefix(key, "_") || strings.HasPrefix(key, "=") {
-		return key, false
-	}
-
-	return KeyHandler(key), true
+func keyHandler(key string) string {
+	key = strings.ReplaceAll(replacer.ToSNAKE(key), "__", "_")
+	return strings.ToUpper(trim(key))
 }

env/util_test.go

@@ -5,13 +5,16 @@ import (
 	"os"
 	"testing"
 
+	"github.com/stretchr/testify/assert"
+
 	"github.com/pubgo/funk/env"
 	"github.com/pubgo/funk/log"
-	"github.com/pubgo/funk/pretty"
-	"github.com/samber/lo"
-	"github.com/stretchr/testify/assert"
 )
 
+func init() {
+	slog.SetDefault(slog.New(log.NewSlog(log.GetLogger(""))))
+}
+
 func TestResetEnv(t *testing.T) {
 	assert.NoError(t, os.Setenv("abc", "1"))
 	assert.Equal(t, os.Getenv("abc"), "1")
@@ -26,16 +29,11 @@ func TestNormalize(t *testing.T) {
 }
 
 func TestEnvPrefix(t *testing.T) {
-	slog.SetDefault(slog.New(log.NewSlog(log.GetLogger(""))))
-
 	env.Reload()
-	pretty.Println("env_keys", lo.Keys(env.Map()))
 
-	env.Set(env.PrefixKey, "test").Must()
-	env.Set("test_hello", "world").Must()
+	env.MustSet("test_hello", "world")
 	env.Reload()
 
 	envMap := env.Map()
 	assert.Equal(t, envMap["TEST_HELLO"], "world")
-	pretty.Println(os.Environ())
 }

v2/result/future.go

@@ -0,0 +1,68 @@
+package result
+
+import (
+	"context"
+
+	"github.com/pubgo/funk/assert"
+	"github.com/samber/lo"
+)
+
+func AsyncErr(fn func() Error) ErrFuture {
+	assert.If(fn == nil, "[fn] is nil")
+
+	var future = newErrFuture()
+	go func() { defer future.close(); future.setErr(try(func() error { return fn().getErr() })) }()
+	return future
+}
+
+func Async[T any](fn func() Result[T]) *Future[T] {
+	assert.If(fn == nil, "[fn] is nil")
+
+	var future = newFuture[T]()
+	go func() { defer future.close(); future.setVal(tryResult(fn)) }()
+	return future
+}
+
+func newFuture[T any]() *Future[T] {
+	return &Future[T]{done: make(chan struct{})}
+}
+
+type Future[T any] struct {
+	v    Result[T]
+	done chan struct{}
+}
+
+func (f *Future[T]) close()               { close(f.done) }
+func (f *Future[T]) setVal(val Result[T]) { f.v = val }
+
+func (f *Future[T]) Await(ctxL ...context.Context) Result[T] {
+	ctx := lo.FirstOr(ctxL, context.Background())
+	select {
+	case <-f.done:
+		return f.v
+	case <-ctx.Done():
+		return f.v.WithErr(ctx.Err())
+	}
+}
+
+func newErrFuture() ErrFuture {
+	return ErrFuture{done: make(chan struct{})}
+}
+
+type ErrFuture struct {
+	e    error
+	done chan struct{}
+}
+
+func (f *ErrFuture) close()           { close(f.done) }
+func (f *ErrFuture) setErr(err error) { f.e = err }
+
+func (f *ErrFuture) Await(ctxL ...context.Context) Error {
+	ctx := lo.FirstOr(ctxL, context.Background())
+	select {
+	case <-f.done:
+		return ErrOf(f.e)
+	case <-ctx.Done():
+		return ErrOf(ctx.Err())
+	}
+}