diff options
Diffstat (limited to 'env.go')
| -rw-r--r-- | env.go | 154 |
1 files changed, 112 insertions, 42 deletions
@@ -1,72 +1,142 @@ package envelope import ( - "fmt" "os" "reflect" - "strconv" ) -func LoadFromEnv(ptr interface{}) error { +// LoadFromEnv populates a struct with values from environment variables. +// +// The function takes a pointer to a struct and looks for fields with the `env` tag. +// For each field with an `env` tag, it attempts to load the corresponding environment +// variable and parse it into the field's type. +// +// Supported types include: +// - string +// - bool +// - int, int8, int16, int32, int64 +// - uint, uint8, uint16, uint32, uint64 +// - float32, float64 +// - time.Time (RFC3339 format) +// - time.Duration +// - net.IP +// - net.IPNet (CIDR notation) +// - url.URL +// - []string, []int (comma-separated) +// - Nested structs +// - Custom types (via registered type parsers) +// +// For nested structs, the parent field's `env` tag is used as a prefix for all fields +// in the nested struct. If the parent field doesn't have an `env` tag, no prefix is added. +// +// You can override the default parsers or add support for custom types using +// RegisterTypeParser. This allows you to customize how environment variable values +// are converted to specific types, including the built-in types. +// +// Example: +// +// type Config struct { +// Host string `env:"HOST"` +// Port int `env:"PORT"` +// Timeout time.Duration `env:"TIMEOUT"` +// Server struct { +// MaxConns int `env:"MAX_CONNS"` +// } `env:"SERVER"` +// } +// +// // This would look for environment variables: +// // HOST, PORT, TIMEOUT, SERVER_MAX_CONNS +// +// Returns an error if the input is not a pointer to a struct, or if any value +// cannot be parsed into the corresponding field type. +func LoadFromEnv(ptr any) error { v := reflect.ValueOf(ptr) if v.Kind() != reflect.Ptr || v.Elem().Kind() != reflect.Struct { - return fmt.Errorf("ptr must be a pointer to a struct") + return newNotPointerToStructError(v.Type()) } v = v.Elem() - t := v.Type() + return loadStructFromEnv(v, "") +} - for i := 0; i < t.NumField(); i++ { +func loadStructFromEnv(v reflect.Value, prefix string) error { + t := v.Type() + for i := range t.NumField() { field := t.Field(i) fieldValue := v.Field(i) - envName := field.Tag.Get("env") - if envName == "" { - continue // Skip if the tag isn't set. + if !fieldValue.CanSet() { + continue } - envValue := os.Getenv(envName) - if envValue == "" { - continue // Skip if the environment variable is not set. + if fieldValue.Kind() == reflect.Struct { + if _, hasParser := typeParserRegistry[fieldValue.Type()]; !hasParser { + if err := loadNestedStructFromEnv(fieldValue, field, prefix); err != nil { + return err + } + continue + } } - if err := setFieldValue(fieldValue, envValue); err != nil { - return fmt.Errorf("error while setting field %s from environment variable %s: %w", field.Name, envName, err) + envTag := field.Tag.Get("env") + if envTag == "" { + continue + } + if err := loadFieldFromEnv(fieldValue, field, envTag, prefix); err != nil { + return err } } return nil } -func setFieldValue(field reflect.Value, value string) error { - switch field.Kind() { - case reflect.String: - field.SetString(value) - case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64: - intValue, err := strconv.ParseInt(value, 10, 64) - if err != nil { - return fmt.Errorf("unable to parse %s as an integer: %w", value, err) +func loadNestedStructFromEnv(fieldValue reflect.Value, field reflect.StructField, parentPrefix string) error { + // For nested structs, they can have 'env' struct tags + // that indicate a prefix for their nested fields when + // parsing them. + // + // e.g. if the parent struct has a tag of "USER" and it + // has an inner field with a tag of "NAME", the environment + // variable would be "USER_NAME". + var nestedPrefix string + envTag := field.Tag.Get("env") + if envTag != "" { + if parentPrefix != "" { + nestedPrefix = parentPrefix + "_" + envTag + } else { + nestedPrefix = envTag } - field.SetInt(intValue) - case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64: - uintValue, err := strconv.ParseUint(value, 10, 64) - if err != nil { - return fmt.Errorf("unable to parse %s as an unsigned integer: %w", value, err) - } - field.SetUint(uintValue) - case reflect.Bool: - boolValue, err := strconv.ParseBool(value) - if err != nil { - return fmt.Errorf("unable to parse %s as an boolean: %w", value, err) - } - field.SetBool(boolValue) - case reflect.Float32, reflect.Float64: - floatValue, err := strconv.ParseFloat(value, 64) + } else { + nestedPrefix = parentPrefix + } + + return loadStructFromEnv(fieldValue, nestedPrefix) +} + +func loadFieldFromEnv(fieldValue reflect.Value, field reflect.StructField, envTag string, prefix string) error { + envName := buildEnvVarName(envTag, prefix) + envValue := os.Getenv(envName) + if envValue == "" { + return nil + } + return parseAndSetFieldValue(fieldValue, field, envValue, envName) +} + +func buildEnvVarName(envTag string, prefix string) string { + if prefix != "" { + return prefix + "_" + envTag + } + return envTag +} + +func parseAndSetFieldValue(fieldValue reflect.Value, field reflect.StructField, envValue string, envName string) error { + if parser, exists := typeParserRegistry[fieldValue.Type()]; exists { + val, err := parser.Parse(envValue) if err != nil { - return fmt.Errorf("unable to parse %s as an float: %w", value, err) + return newParseError(field.Name, envName, envValue, fieldValue.Type(), err) } - field.SetFloat(floatValue) - default: - return fmt.Errorf("unsupported field type: %s", field.Kind()) + fieldValue.Set(reflect.ValueOf(val)) + return nil } - return nil + + return newUnsupportedTypeError(field.Name, fieldValue.Type()) } |