chore: quick update fix/version at 2025-10-29 21:10:38

Author: kooksee

cmds/envcmd/cmd.go

@@ -22,7 +22,7 @@ func New() *cli.Command {
 			env.Reload()
 
 			fmt.Println("config path:", config.GetConfigPath())
-			envs := config.LoadEnvConfigMap(config.GetConfigPath())
+			envs := config.LoadEnvMap(config.GetConfigPath())
 			for name, cfg := range envs {
 				envData := env.Get(name)
 				if envData != "" {

config/config.go

@@ -73,7 +73,7 @@ func GetConfigData(cfgPath string) (_ []byte, gErr error) {
 	return configBytes, nil
 }
 
-func LoadEnvConfigMap(cfgPath string) EnvSpecMap { return loadEnvConfigMap(cfgPath) }
+func LoadEnvMap(cfgPath string) EnvSpecMap { return loadEnvConfigMap(cfgPath) }
 
 func loadEnvConfigMap(cfgPath string) EnvSpecMap {
 	defer recovery.Exit(func(err error) error {
@@ -103,19 +103,26 @@ func loadEnvConfigMap(cfgPath string) EnvSpecMap {
 			envConfigBytes := result.Wrap(os.ReadFile(p)).
 				Map(bytes.TrimSpace).
 				Must(func(e *zerolog.Event) {
-					e.Str(logfields.Msg, fmt.Sprintf("failed to handler env config data, path=%s", p))
+					e.Str("env_path", p)
+					e.Str(logfields.Msg, "failed to handler env config data")
 				})
 			if len(envConfigBytes) == 0 {
 				continue
 			}
 
 			envConfigBytes = cfgFormat(envConfigBytes, &config{workDir: filepath.Dir(cfgPath)})
-			envConfigBytes = result.Wrap(envsubst.Bytes(envConfigBytes)).Must(func(e *zerolog.Event) {
-				e.Str(logfields.Msg, fmt.Sprintf("failed to handler config env data: %s", envConfigBytes))
-			})
-			result.Must(yaml.Unmarshal(envConfigBytes, &envSpecMap), func(e *zerolog.Event) {
-				e.Str(logfields.Msg, fmt.Sprintf("failed to unmarshal env config, data=%s path=%s", envConfigBytes, p))
-			})
+			envConfigBytes = result.Wrap(envsubst.Bytes(envConfigBytes)).
+				Must(func(e *zerolog.Event) {
+					e.Str("env_path", p)
+					e.Str("env_data", string(envConfigBytes))
+					e.Str(logfields.Msg, "failed to handler config env")
+				})
+			result.ErrOf(yaml.Unmarshal(envConfigBytes, &envSpecMap)).
+				Must(func(e *zerolog.Event) {
+					e.Str("env_data", string(envConfigBytes))
+					e.Str("env_path", p)
+					e.Str(logfields.Msg, "failed to unmarshal env config")
+				})
 		}
 	}
 	initEnv(envSpecMap)

result/api.go

@@ -57,12 +57,12 @@ func Errorf(msg string, args ...any) Error {
 	return newError(errors.WrapCaller(fmt.Errorf(msg, args...), 1))
 }
 
-func ErrProxyOf(err *error) ErrProxy {
+func ErrProxyOf(err *error) ProxyErr {
 	if err == nil {
 		errNilOrPanic(errors.Errorf("err param is nil"))
-		return ErrProxy{}
+		return ProxyErr{}
 	}
-	return ErrProxy{err: err}
+	return ProxyErr{err: err}
 }
 
 func ErrOf(err error) Error {

result/error.go

@@ -115,7 +115,7 @@ func (e Error) Expect(format string, args ...any) {
 
 func (e Error) String() string {
 	if e.IsOK() {
-		return "Ok"
+		return "OK"
 	}
 
 	return fmt.Sprintf("Error(%v)", e.err)

result/future.go

@@ -8,13 +8,16 @@ import (
 	"github.com/pubgo/funk/v2/errors"
 )
 
-func AsyncErr(fn func() Error) *ErrFuture {
+func AsyncErr(fn func() Error) *FutureErr {
 	if fn == nil {
-		return &ErrFuture{e: errors.WrapCaller(errFnIsNil, 1)}
+		return &FutureErr{e: errors.WrapCaller(errFnIsNil, 1)}
 	}
 
 	future := newErrFuture()
-	go func() { defer future.close(); future.setErr(try(func() error { return fn().getErr() })) }()
+	go func() {
+		defer future.close()
+		future.setErr(try(func() error { return fn().getErr() }))
+	}()
 	return future
 }
 
@@ -53,19 +56,19 @@ func (f *Future[T]) Await(ctxL ...context.Context) Result[T] {
 	}
 }
 
-func newErrFuture() *ErrFuture {
-	return &ErrFuture{done: make(chan struct{})}
+func newErrFuture() *FutureErr {
+	return &FutureErr{done: make(chan struct{})}
 }
 
-type ErrFuture struct {
+type FutureErr struct {
 	e    error
 	done chan struct{}
 }
 
-func (f *ErrFuture) close()           { close(f.done) }
-func (f *ErrFuture) setErr(err error) { f.e = err }
+func (f *FutureErr) close()           { close(f.done) }
+func (f *FutureErr) setErr(err error) { f.e = err }
 
-func (f *ErrFuture) Await(ctxL ...context.Context) Error {
+func (f *FutureErr) Await(ctxL ...context.Context) Error {
 	ctx := lo.FirstOr(ctxL, context.Background())
 	select {
 	case <-f.done:

result/proxy.go

@@ -6,31 +6,31 @@ import (
 	"github.com/samber/lo"
 )
 
-var _ ErrSetter = new(ErrProxy)
+var _ ErrSetter = new(ProxyErr)
 
-type ErrProxy struct {
+type ProxyErr struct {
 	err *error
 }
 
-func (e ErrProxy) IsOK() bool {
+func (e ProxyErr) IsOK() bool {
 	return lo.FromPtr(e.err) == nil
 }
 
-func (e ErrProxy) IsErr() bool {
+func (e ProxyErr) IsErr() bool {
 	return lo.FromPtr(e.err) != nil
 }
 
-func (e ErrProxy) GetErr() error {
+func (e ProxyErr) GetErr() error {
 	return lo.FromPtr(e.err)
 }
 
-func (e ErrProxy) String() string {
+func (e ProxyErr) String() string {
 	if e.IsOK() {
-		return "Ok"
+		return "OK"
 	}
 
 	return fmt.Sprintf("Error(%v)", lo.FromPtr(e.err))
 }
 
-func (e ErrProxy) setErrorInner() {
+func (e ProxyErr) setErrorInner() {
 }

result/result.go

@@ -177,7 +177,7 @@ func (r Result[T]) GetErr() error {
 
 func (r Result[T]) String() string {
 	if r.IsOK() {
-		return fmt.Sprintf("Ok(%v)", r.getValue())
+		return fmt.Sprintf("OK(%v)", r.getValue())
 	}
 	return fmt.Sprintf("Error(%v)", r.getErr())
 }

result/util.go

@@ -234,9 +234,9 @@ func setError(setter ErrSetter, err error) {
 	switch errSet := setter.(type) {
 	case *Error:
 		errSet.err = err
-	case *ErrProxy:
+	case *ProxyErr:
 		*errSet.err = err
-	case ErrProxy:
+	case ProxyErr:
 		*errSet.err = err
 	default:
 		rv := reflect.ValueOf(setter)
@@ -269,7 +269,7 @@ func logErr(ctx context.Context, skip int, err error, events ...func(e *zerolog.
 
 	log.Error(ctx).
 		Func(func(e *zerolog.Event) {
-			e.Str(logfields.Module, "result2")
+			e.Str(logfields.Module, "result")
 			e.Strs(logfields.ErrorStack, lo.Map(traces, func(item *stack.Frame, index int) string { return item.String() }))
 			e.Str(logfields.ErrorID, errors.GetErrorId(err))
 			e.Str(logfields.ErrorDetail, fmt.Sprintf("%v", err))