👷 Created Docker image build workflow

.gitea/workflows/build-image.yml

@@ -0,0 +1,44 @@
+---
+on:
+  push:
+    branches:
+      - master
+      - develop
+
+env:
+  DOCKER_REGISTRY: source.toby3d.me
+
+jobs:
+  docker:
+    runs-on: ubuntu-latest
+    container:
+      image: catthehacker/ubuntu:act-latest
+    permissions:
+      contents: read
+      packages: write
+    steps:
+      - name: Checkout
+        uses: https://gitea.com/actions/checkout@v3
+
+      - name: Set up QEMU
+        uses: https://gitea.com/docker/setup-qemu-action@v2
+
+      - name: Set up Docker BuildX
+        uses: https://gitea.com/docker/setup-buildx-action@v2
+
+      - name: Login to registry
+        uses: https://gitea.com/docker/login-action@v2
+        with:
+          registry: ${{ env.DOCKER_REGISTRY }}
+          username: ${{ gitea.repository_owner }}
+          password: ${{ secrets.DOCKER_TOKEN }}
+
+      - name: Build and push
+        uses: https://gitea.com/docker/build-push-action@v4
+        env:
+          ACTIONS_RUNTIME_TOKEN: "" # See https://gitea.com/gitea/act_runner/issues/119
+        with:
+          context: .
+          file: ./build/Dockerfile
+          push: true
+          tags: ${{ env.DOCKER_REGISTRY }}/${{ gitea.repository }}:${{ gitea.ref_name }}

build/Dockerfile

@@ -0,0 +1,27 @@
+# syntax=docker/dockerfile:1
+# docker build --rm -f build/Dockerfile -t source.toby3d.me/toby3d/home .
+
+# Build
+FROM golang:alpine AS builder
+
+WORKDIR /app
+
+ENV CGO_ENABLED=0
+ENV GOFLAGS="-mod=vendor -buildvcs=true"
+
+COPY go.mod go.sum *.go ./
+COPY internal ./internal/
+COPY vendor ./vendor/
+
+RUN go build -o ./home
+
+# Run
+FROM scratch
+
+WORKDIR /
+
+COPY --from=builder /app/home /home
+
+EXPOSE 3000
+
+ENTRYPOINT ["/home"]

go.mod

@@ -0,0 +1,5 @@
+module source.toby3d.me/toby3d/home
+
+go 1.21.3
+
+require github.com/caarlos0/env/v10 v10.0.0

go.sum

@@ -0,0 +1,2 @@
+github.com/caarlos0/env/v10 v10.0.0 h1:yIHUBZGsyqCnpTkbjk8asUlx6RFhhEs+h7TOBdgdzXA=
+github.com/caarlos0/env/v10 v10.0.0/go.mod h1:ZfulV76NvVPw3tm591U4SwL3Xx9ldzBP9aGxzeN7G18=

internal/domain/config.go

@@ -0,0 +1,16 @@
+package domain
+
+import (
+	"net"
+	"net/netip"
+	"strconv"
+)
+
+type Config struct {
+	Host string `env:"HOME_HOST"`
+	Port uint16 `env:"HOME_PORT" envDefault:"3000"`
+}
+
+func (c Config) AddrPort() netip.AddrPort {
+	return netip.MustParseAddrPort(net.JoinHostPort(c.Host, strconv.FormatUint(uint64(c.Port), 16)))
+}

main.go

@@ -0,0 +1,94 @@
+package main
+
+import (
+	"context"
+	"flag"
+	"fmt"
+	"log"
+	"net/http"
+	"os"
+	"os/signal"
+	"runtime"
+	"runtime/pprof"
+	"syscall"
+
+	"github.com/caarlos0/env/v10"
+
+	"source.toby3d.me/toby3d/home/internal/domain"
+)
+
+var (
+	config = new(domain.Config)
+	logger = log.New(os.Stdout, "home\t", log.Lmsgprefix|log.LstdFlags|log.LUTC)
+)
+
+var cpuProfilePath, memProfilePath string
+
+func init() {
+	flag.StringVar(&cpuProfilePath, "cpuprofile", "", "set path to saving CPU memory profile")
+	flag.StringVar(&memProfilePath, "memprofile", "", "set path to saving pprof memory profile")
+	flag.Parse()
+
+	if err := env.ParseWithOptions(config, env.Options{
+		Prefix: "HOME_",
+	}); err != nil {
+		logger.Fatalln("cannot unmarshal configuration into domain:", err)
+	}
+}
+
+func main() {
+	ctx := context.Background()
+
+	server := &http.Server{
+		Addr: config.AddrPort().String(),
+		Handler: http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
+			fmt.Fprintln(w, "hello, world!")
+		}),
+	}
+
+	done := make(chan os.Signal, 1)
+	signal.Notify(done, os.Interrupt, syscall.SIGINT, syscall.SIGTERM)
+
+	if cpuProfilePath != "" {
+		cpuProfile, err := os.Create(cpuProfilePath)
+		if err != nil {
+			logger.Fatalln("could not create CPU profile:", err)
+		}
+		defer cpuProfile.Close()
+
+		if err = pprof.StartCPUProfile(cpuProfile); err != nil {
+			logger.Fatalln("could not start CPU profile:", err)
+		}
+		defer pprof.StopCPUProfile()
+	}
+
+	go func(server *http.Server) {
+		logger.Printf("starting server on %d...", config.Port)
+
+		if err := server.ListenAndServe(); err != nil {
+			logger.Fatalln("cannot listen and serve server:", err)
+		}
+	}(server)
+
+	<-done
+
+	if err := server.Shutdown(ctx); err != nil {
+		logger.Fatalln("failed shutdown server:", err)
+	}
+
+	if memProfilePath == "" {
+		return
+	}
+
+	memProfile, err := os.Create(memProfilePath)
+	if err != nil {
+		logger.Fatalln("could not create memory profile:", err)
+	}
+	defer memProfile.Close()
+
+	runtime.GC() // NOTE(toby3d): get up-to-date statistics
+
+	if err = pprof.WriteHeapProfile(memProfile); err != nil {
+		logger.Fatalln("could not write memory profile:", err)
+	}
+}

vendor/github.com/caarlos0/env/v10/.gitignore

@@ -0,0 +1,4 @@
+coverage.txt
+bin
+card.png
+dist

vendor/github.com/caarlos0/env/v10/.golangci.yml

@@ -0,0 +1,8 @@
+linters:
+  enable:
+    - thelper
+    - gofumpt
+    - tparallel
+    - unconvert
+    - unparam
+    - wastedassign

vendor/github.com/caarlos0/env/v10/.goreleaser.yml

@@ -0,0 +1,3 @@
+includes:
+  - from_url:
+      url: https://raw.githubusercontent.com/caarlos0/.goreleaserfiles/main/lib.yml

vendor/github.com/caarlos0/env/v10/.mailmap

@@ -0,0 +1,7 @@
+Carlos Alexandro Becker <caarlos0@users.noreply.github.com> Carlos A Becker <caarlos0@gmail.com>
+Carlos Alexandro Becker <caarlos0@users.noreply.github.com> Carlos A Becker <caarlos0@users.noreply.github.com>
+Carlos Alexandro Becker <caarlos0@users.noreply.github.com> Carlos Alexandro Becker <caarlos0@gmail.com>
+Carlos Alexandro Becker <caarlos0@users.noreply.github.com> Carlos Alexandro Becker <caarlos0@users.noreply.github.com>
+Carlos Alexandro Becker <caarlos0@users.noreply.github.com> Carlos Becker <caarlos0@gmail.com>
+dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com> dependabot-preview[bot] <27856297+dependabot-preview[bot]@users.noreply.github.com>
+actions-user <actions@github.com> github-actions[bot] <41898282+github-actions[bot]@users.noreply.github.com>

vendor/github.com/caarlos0/env/v10/LICENSE.md

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2015-2022 Carlos Alexandro Becker
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

vendor/github.com/caarlos0/env/v10/Makefile

@@ -0,0 +1,37 @@
+SOURCE_FILES?=./...
+TEST_PATTERN?=.
+
+export GO111MODULE := on
+
+setup:
+	go mod tidy
+.PHONY: setup
+
+build:
+	go build
+.PHONY: build
+
+test:
+	go test -v -failfast -race -coverpkg=./... -covermode=atomic -coverprofile=coverage.txt $(SOURCE_FILES) -run $(TEST_PATTERN) -timeout=2m
+.PHONY: test
+
+cover: test
+	go tool cover -html=coverage.txt
+.PHONY: cover
+
+fmt:
+	gofumpt -w -l .
+.PHONY: fmt
+
+lint:
+	golangci-lint run ./...
+.PHONY: lint
+
+ci: build test
+.PHONY: ci
+
+card:
+	wget -O card.png -c "https://og.caarlos0.dev/**env**: parse envs to structs.png?theme=light&md=1&fontSize=100px&images=https://github.com/caarlos0.png"
+.PHONY: card
+
+.DEFAULT_GOAL := ci

vendor/github.com/caarlos0/env/v10/README.md

@@ -0,0 +1,610 @@
+# env
+
+[![Build Status](https://img.shields.io/github/actions/workflow/status/caarlos0/env/build.yml?branch=main&style=for-the-badge)](https://github.com/caarlos0/env/actions?workflow=build)
+[![Coverage Status](https://img.shields.io/codecov/c/gh/caarlos0/env.svg?logo=codecov&style=for-the-badge)](https://codecov.io/gh/caarlos0/env)
+[![](http://img.shields.io/badge/godoc-reference-5272B4.svg?style=for-the-badge)](https://pkg.go.dev/github.com/caarlos0/env/v10)
+
+A simple and zero-dependencies library to parse environment variables into
+`struct`s.
+
+## Example
+
+Get the module with:
+
+```sh
+go get github.com/caarlos0/env/v10
+```
+
+The usage looks like this:
+
+```go
+package main
+
+import (
+	"fmt"
+	"time"
+
+	"github.com/caarlos0/env/v10"
+)
+
+type config struct {
+	Home         string         `env:"HOME"`
+	Port         int            `env:"PORT" envDefault:"3000"`
+	Password     string         `env:"PASSWORD,unset"`
+	IsProduction bool           `env:"PRODUCTION"`
+	Duration     time.Duration  `env:"DURATION"`
+	Hosts        []string       `env:"HOSTS" envSeparator:":"`
+	TempFolder   string         `env:"TEMP_FOLDER,expand" envDefault:"${HOME}/tmp"`
+	StringInts   map[string]int `env:"MAP_STRING_INT"`
+}
+
+func main() {
+	cfg := config{}
+	if err := env.Parse(&cfg); err != nil {
+		fmt.Printf("%+v\n", err)
+	}
+
+	fmt.Printf("%+v\n", cfg)
+}
+```
+
+You can run it like this:
+
+```sh
+$ PRODUCTION=true HOSTS="host1:host2:host3" DURATION=1s MAP_STRING_INT=k1:1,k2:2 go run main.go
+{Home:/your/home Port:3000 IsProduction:true Hosts:[host1 host2 host3] Duration:1s StringInts:map[k1:1 k2:2]}
+```
+
+## Caveats
+
+> **Warning**
+>
+> **This is important!**
+
+- _Unexported fields_ are **ignored**
+
+## Supported types and defaults
+
+Out of the box all built-in types are supported, plus a few others that
+are commonly used.
+
+Complete list:
+
+- `string`
+- `bool`
+- `int`
+- `int8`
+- `int16`
+- `int32`
+- `int64`
+- `uint`
+- `uint8`
+- `uint16`
+- `uint32`
+- `uint64`
+- `float32`
+- `float64`
+- `time.Duration`
+- `encoding.TextUnmarshaler`
+- `url.URL`
+
+Pointers, slices and slices of pointers, and maps of those types are also
+supported.
+
+You can also use/define a [custom parser func](#custom-parser-funcs) for any
+other type you want.
+
+You can also use custom keys and values in your maps, as long as you provide a
+parser function for them.
+
+If you set the `envDefault` tag for something, this value will be used in the
+case of absence of it in the environment.
+
+By default, slice types will split the environment value on `,`; you can change
+this behavior by setting the `envSeparator` tag. For map types, the default
+separator between key and value is `:` and `,` for key-value pairs.
+The behavior can be changed by setting the `envKeyValSeparator` and
+`envSeparator` tags accordingly.
+
+## Custom Parser Funcs
+
+If you have a type that is not supported out of the box by the lib, you are able
+to use (or define) and pass custom parsers (and their associated `reflect.Type`)
+to the `env.ParseWithOptions()` function.
+
+In addition to accepting a struct pointer (same as `Parse()`), this function
+also accepts a `Options{}`, and you can set your custom parsers in the `FuncMap`
+field.
+
+If you add a custom parser for, say `Foo`, it will also be used to parse
+`*Foo` and `[]Foo` types.
+
+Check the examples in the [go doc](http://pkg.go.dev/github.com/caarlos0/env/v10)
+for more info.
+
+### A note about `TextUnmarshaler` and `time.Time`
+
+Env supports by default anything that implements the `TextUnmarshaler` interface.
+That includes things like `time.Time` for example.
+The upside is that depending on the format you need, you don't need to change
+anything.
+The downside is that if you do need time in another format, you'll need to
+create your own type.
+
+Its fairly straightforward:
+
+```go
+type MyTime time.Time
+
+func (t *MyTime) UnmarshalText(text []byte) error {
+	tt, err := time.Parse("2006-01-02", string(text))
+	*t = MyTime(tt)
+	return err
+}
+
+type Config struct {
+	SomeTime MyTime `env:"SOME_TIME"`
+}
+```
+
+And then you can parse `Config` with `env.Parse`.
+
+## Required fields
+
+The `env` tag option `required` (e.g., `env:"tagKey,required"`) can be added to
+ensure that some environment variable is set. In the example above, an error is
+returned if the `config` struct is changed to:
+
+```go
+type config struct {
+	SecretKey string `env:"SECRET_KEY,required"`
+}
+```
+
+> **Warning**
+>
+> Note that being set is not the same as being empty.
+> If the variable is set, but empty, the field will have its type's default
+> value.
+> This also means that custom parser funcs will not be invoked.
+
+## Expand vars
+
+If you set the `expand` option, environment variables (either in `${var}` or
+`$var` format) in the string will be replaced according with the actual value
+of the variable. For example:
+
+```go
+type config struct {
+	SecretKey string `env:"SECRET_KEY,expand"`
+}
+```
+
+This also works with `envDefault`:
+
+```go
+import (
+	"fmt"
+	"github.com/caarlos0/env/v10"
+)
+
+type config struct {
+	Host     string `env:"HOST" envDefault:"localhost"`
+	Port     int    `env:"PORT" envDefault:"3000"`
+	Address  string `env:"ADDRESS,expand" envDefault:"$HOST:${PORT}"`
+}
+
+func main() {
+	cfg := config{}
+	if err := env.Parse(&cfg); err != nil {
+		fmt.Printf("%+v\n", err)
+	}
+	fmt.Printf("%+v\n", cfg)
+}
+```
+
+results in this:
+
+```sh
+$ PORT=8080 go run main.go
+{Host:localhost Port:8080 Address:localhost:8080}
+```
+
+## Not Empty fields
+
+While `required` demands the environment variable to be set, it doesn't check
+its value. If you want to make sure the environment is set and not empty, you
+need to use the `notEmpty` tag option instead (`env:"SOME_ENV,notEmpty"`).
+
+Example:
+
+```go
+type config struct {
+	SecretKey string `env:"SECRET_KEY,notEmpty"`
+}
+```
+
+## Unset environment variable after reading it
+
+The `env` tag option `unset` (e.g., `env:"tagKey,unset"`) can be added
+to ensure that some environment variable is unset after reading it.
+
+Example:
+
+```go
+type config struct {
+	SecretKey string `env:"SECRET_KEY,unset"`
+}
+```
+
+## From file
+
+The `env` tag option `file` (e.g., `env:"tagKey,file"`) can be added
+in order to indicate that the value of the variable shall be loaded from a
+file.
+The path of that file is given by the environment variable associated with it:
+
+```go
+package main
+
+import (
+	"fmt"
+	"time"
+
+	"github.com/caarlos0/env/v10"
+)
+
+type config struct {
+	Secret      string `env:"SECRET,file"`
+	Password    string `env:"PASSWORD,file"           envDefault:"/tmp/password"`
+	Certificate string `env:"CERTIFICATE,file,expand" envDefault:"${CERTIFICATE_FILE}"`
+}
+
+func main() {
+	cfg := config{}
+	if err := env.Parse(&cfg); err != nil {
+		fmt.Printf("%+v\n", err)
+	}
+
+	fmt.Printf("%+v\n", cfg)
+}
+```
+
+```sh
+$ echo qwerty > /tmp/secret
+$ echo dvorak > /tmp/password
+$ echo coleman > /tmp/certificate
+
+$ SECRET=/tmp/secret  \
+	CERTIFICATE_FILE=/tmp/certificate \
+	go run main.go
+{Secret:qwerty Password:dvorak Certificate:coleman}
+```
+
+## Options
+
+### Use field names as environment variables by default
+
+If you don't want to set the `env` tag on every field, you can use the
+`UseFieldNameByDefault` option.
+
+It will use the field name as environment variable name.
+
+Here's an example:
+
+```go
+package main
+
+import (
+	"fmt"
+	"log"
+
+	"github.com/caarlos0/env/v10"
+)
+
+type Config struct {
+	Username     string // will use $USERNAME
+	Password     string // will use $PASSWORD
+	UserFullName string // will use $USER_FULL_NAME
+}
+
+func main() {
+	cfg := &Config{}
+	opts := env.Options{UseFieldNameByDefault: true}
+
+	// Load env vars.
+	if err := env.ParseWithOptions(cfg, opts); err != nil {
+		log.Fatal(err)
+	}
+
+	// Print the loaded data.
+	fmt.Printf("%+v\n", cfg)
+}
+```
+
+### Environment
+
+By setting the `Options.Environment` map you can tell `Parse` to add those
+`keys` and `values` as `env` vars before parsing is done.
+These `envs` are stored in the map and never actually set by `os.Setenv`.
+This option effectively makes `env` ignore the OS environment variables: only
+the ones provided in the option are used.
+
+This can make your testing scenarios a bit more clean and easy to handle.
+
+```go
+package main
+
+import (
+	"fmt"
+	"log"
+
+	"github.com/caarlos0/env/v10"
+)
+
+type Config struct {
+	Password string `env:"PASSWORD"`
+}
+
+func main() {
+	cfg := &Config{}
+	opts := env.Options{Environment: map[string]string{
+		"PASSWORD": "MY_PASSWORD",
+	}}
+
+	// Load env vars.
+	if err := env.ParseWithOptions(cfg, opts); err != nil {
+		log.Fatal(err)
+	}
+
+	// Print the loaded data.
+	fmt.Printf("%+v\n", cfg)
+}
+```
+
+### Changing default tag name
+
+You can change what tag name to use for setting the env vars by setting the
+`Options.TagName` variable.
+
+For example
+
+```go
+package main
+
+import (
+	"fmt"
+	"log"
+
+	"github.com/caarlos0/env/v10"
+)
+
+type Config struct {
+	Password string `json:"PASSWORD"`
+}
+
+func main() {
+	cfg := &Config{}
+	opts := env.Options{TagName: "json"}
+
+	// Load env vars.
+	if err := env.ParseWithOptions(cfg, opts); err != nil {
+		log.Fatal(err)
+	}
+
+	// Print the loaded data.
+	fmt.Printf("%+v\n", cfg)
+}
+```
+
+### Prefixes
+
+You can prefix sub-structs env tags, as well as a whole `env.Parse` call.
+
+Here's an example flexing it a bit:
+
+```go
+package main
+
+import (
+	"fmt"
+	"log"
+
+	"github.com/caarlos0/env/v10"
+)
+
+type Config struct {
+	Home string `env:"HOME"`
+}
+
+type ComplexConfig struct {
+	Foo   Config `envPrefix:"FOO_"`
+	Clean Config
+	Bar   Config `envPrefix:"BAR_"`
+	Blah  string `env:"BLAH"`
+}
+
+func main() {
+	cfg := &ComplexConfig{}
+	opts := env.Options{
+		Prefix: "T_",
+		Environment: map[string]string{
+			"T_FOO_HOME": "/foo",
+			"T_BAR_HOME": "/bar",
+			"T_BLAH":     "blahhh",
+			"T_HOME":     "/clean",
+		},
+	}
+
+	// Load env vars.
+	if err := env.ParseWithOptions(cfg, opts); err != nil {
+		log.Fatal(err)
+	}
+
+	// Print the loaded data.
+	fmt.Printf("%+v\n", cfg)
+}
+```
+
+### On set hooks
+
+You might want to listen to value sets and, for example, log something or do
+some other kind of logic.
+You can do this by passing a `OnSet` option:
+
+```go
+package main
+
+import (
+	"fmt"
+	"log"
+
+	"github.com/caarlos0/env/v10"
+)
+
+type Config struct {
+	Username string `env:"USERNAME" envDefault:"admin"`
+	Password string `env:"PASSWORD"`
+}
+
+func main() {
+	cfg := &Config{}
+	opts := env.Options{
+		OnSet: func(tag string, value interface{}, isDefault bool) {
+			fmt.Printf("Set %s to %v (default? %v)\n", tag, value, isDefault)
+		},
+	}
+
+	// Load env vars.
+	if err := env.ParseWithOptions(cfg, opts); err != nil {
+		log.Fatal(err)
+	}
+
+	// Print the loaded data.
+	fmt.Printf("%+v\n", cfg)
+}
+```
+
+## Making all fields to required
+
+You can make all fields that don't have a default value be required by setting
+the `RequiredIfNoDef: true` in the `Options`.
+
+For example
+
+```go
+package main
+
+import (
+	"fmt"
+	"log"
+
+	"github.com/caarlos0/env/v10"
+)
+
+type Config struct {
+	Username string `env:"USERNAME" envDefault:"admin"`
+	Password string `env:"PASSWORD"`
+}
+
+func main() {
+	cfg := &Config{}
+	opts := env.Options{RequiredIfNoDef: true}
+
+	// Load env vars.
+	if err := env.ParseWithOptions(cfg, opts); err != nil {
+		log.Fatal(err)
+	}
+
+	// Print the loaded data.
+	fmt.Printf("%+v\n", cfg)
+}
+```
+
+## Defaults from code
+
+You may define default value also in code, by initialising the config data
+before it's filled by `env.Parse`.
+Default values defined as struct tags will overwrite existing values during
+Parse.
+
+```go
+package main
+
+import (
+	"fmt"
+	"log"
+
+	"github.com/caarlos0/env/v10"
+)
+
+type Config struct {
+	Username string `env:"USERNAME" envDefault:"admin"`
+	Password string `env:"PASSWORD"`
+}
+
+func main() {
+	cfg := Config{
+		Username: "test",
+		Password: "123456",
+	}
+
+	if err := env.Parse(&cfg); err != nil {
+		fmt.Println("failed:", err)
+	}
+
+	fmt.Printf("%+v", cfg) // {Username:admin Password:123456}
+}
+```
+
+## Error handling
+
+You can handle the errors the library throws like so:
+
+```go
+package main
+
+import (
+	"fmt"
+	"log"
+
+	"github.com/caarlos0/env/v10"
+)
+
+type Config struct {
+	Username string `env:"USERNAME" envDefault:"admin"`
+	Password string `env:"PASSWORD"`
+}
+
+func main() {
+	var cfg Config
+	err := env.Parse(&cfg)
+	if e, ok := err.(*env.AggregateError); ok {
+		for _, er := range e.Errors {
+			switch v := er.(type) {
+			case env.ParseError:
+				// handle it
+			case env.NotStructPtrError:
+				// handle it
+			case env.NoParserError:
+				// handle it
+			case env.NoSupportedTagOptionError:
+				// handle it
+			default:
+				fmt.Printf("Unknown error type %v", v)
+			}
+		}
+	}
+
+	fmt.Printf("%+v", cfg) // {Username:admin Password:123456}
+}
+```
+
+> **Info**
+>
+> If you want to check if an specific error is in the chain, you can also use
+> `errors.Is()`.
+
+## Stargazers over time
+
+[![Stargazers over time](https://starchart.cc/caarlos0/env.svg)](https://starchart.cc/caarlos0/env)

vendor/github.com/caarlos0/env/v10/env.go

@@ -0,0 +1,614 @@
+package env
+
+import (
+	"encoding"
+	"fmt"
+	"net/url"
+	"os"
+	"reflect"
+	"strconv"
+	"strings"
+	"time"
+	"unicode"
+)
+
+// nolint: gochecknoglobals
+var (
+	defaultBuiltInParsers = map[reflect.Kind]ParserFunc{
+		reflect.Bool: func(v string) (interface{}, error) {
+			return strconv.ParseBool(v)
+		},
+		reflect.String: func(v string) (interface{}, error) {
+			return v, nil
+		},
+		reflect.Int: func(v string) (interface{}, error) {
+			i, err := strconv.ParseInt(v, 10, 32)
+			return int(i), err
+		},
+		reflect.Int16: func(v string) (interface{}, error) {
+			i, err := strconv.ParseInt(v, 10, 16)
+			return int16(i), err
+		},
+		reflect.Int32: func(v string) (interface{}, error) {
+			i, err := strconv.ParseInt(v, 10, 32)
+			return int32(i), err
+		},
+		reflect.Int64: func(v string) (interface{}, error) {
+			return strconv.ParseInt(v, 10, 64)
+		},
+		reflect.Int8: func(v string) (interface{}, error) {
+			i, err := strconv.ParseInt(v, 10, 8)
+			return int8(i), err
+		},
+		reflect.Uint: func(v string) (interface{}, error) {
+			i, err := strconv.ParseUint(v, 10, 32)
+			return uint(i), err
+		},
+		reflect.Uint16: func(v string) (interface{}, error) {
+			i, err := strconv.ParseUint(v, 10, 16)
+			return uint16(i), err
+		},
+		reflect.Uint32: func(v string) (interface{}, error) {
+			i, err := strconv.ParseUint(v, 10, 32)
+			return uint32(i), err
+		},
+		reflect.Uint64: func(v string) (interface{}, error) {
+			i, err := strconv.ParseUint(v, 10, 64)
+			return i, err
+		},
+		reflect.Uint8: func(v string) (interface{}, error) {
+			i, err := strconv.ParseUint(v, 10, 8)
+			return uint8(i), err
+		},
+		reflect.Float64: func(v string) (interface{}, error) {
+			return strconv.ParseFloat(v, 64)
+		},
+		reflect.Float32: func(v string) (interface{}, error) {
+			f, err := strconv.ParseFloat(v, 32)
+			return float32(f), err
+		},
+	}
+)
+
+func defaultTypeParsers() map[reflect.Type]ParserFunc {
+	return map[reflect.Type]ParserFunc{
+		reflect.TypeOf(url.URL{}): func(v string) (interface{}, error) {
+			u, err := url.Parse(v)
+			if err != nil {
+				return nil, newParseValueError("unable to parse URL", err)
+			}
+			return *u, nil
+		},
+		reflect.TypeOf(time.Nanosecond): func(v string) (interface{}, error) {
+			s, err := time.ParseDuration(v)
+			if err != nil {
+				return nil, newParseValueError("unable to parse duration", err)
+			}
+			return s, err
+		},
+	}
+}
+
+// ParserFunc defines the signature of a function that can be used within `CustomParsers`.
+type ParserFunc func(v string) (interface{}, error)
+
+// OnSetFn is a hook that can be run when a value is set.
+type OnSetFn func(tag string, value interface{}, isDefault bool)
+
+// processFieldFn is a function which takes all information about a field and processes it.
+type processFieldFn func(refField reflect.Value, refTypeField reflect.StructField, opts Options, fieldParams FieldParams) error
+
+// Options for the parser.
+type Options struct {
+	// Environment keys and values that will be accessible for the service.
+	Environment map[string]string
+
+	// TagName specifies another tagname to use rather than the default env.
+	TagName string
+
+	// RequiredIfNoDef automatically sets all env as required if they do not
+	// declare 'envDefault'.
+	RequiredIfNoDef bool
+
+	// OnSet allows to run a function when a value is set.
+	OnSet OnSetFn
+
+	// Prefix define a prefix for each key.
+	Prefix string
+
+	// UseFieldNameByDefault defines whether or not env should use the field
+	// name by default if the `env` key is missing.
+	UseFieldNameByDefault bool
+
+	// Custom parse functions for different types.
+	FuncMap map[reflect.Type]ParserFunc
+
+	// Used internally. maps the env variable key to its resolved string value. (for env var expansion)
+	rawEnvVars map[string]string
+}
+
+func (opts *Options) getRawEnv(s string) string {
+	val := opts.rawEnvVars[s]
+	if val == "" {
+		return opts.Environment[s]
+	}
+	return val
+}
+
+func defaultOptions() Options {
+	return Options{
+		TagName:     "env",
+		Environment: toMap(os.Environ()),
+		FuncMap:     defaultTypeParsers(),
+		rawEnvVars:  make(map[string]string),
+	}
+}
+
+func customOptions(opt Options) Options {
+	defOpts := defaultOptions()
+	if opt.TagName == "" {
+		opt.TagName = defOpts.TagName
+	}
+	if opt.Environment == nil {
+		opt.Environment = defOpts.Environment
+	}
+	if opt.FuncMap == nil {
+		opt.FuncMap = map[reflect.Type]ParserFunc{}
+	}
+	if opt.rawEnvVars == nil {
+		opt.rawEnvVars = defOpts.rawEnvVars
+	}
+	for k, v := range defOpts.FuncMap {
+		if _, exists := opt.FuncMap[k]; !exists {
+			opt.FuncMap[k] = v
+		}
+	}
+	return opt
+}
+
+func optionsWithEnvPrefix(field reflect.StructField, opts Options) Options {
+	return Options{
+		Environment:           opts.Environment,
+		TagName:               opts.TagName,
+		RequiredIfNoDef:       opts.RequiredIfNoDef,
+		OnSet:                 opts.OnSet,
+		Prefix:                opts.Prefix + field.Tag.Get("envPrefix"),
+		UseFieldNameByDefault: opts.UseFieldNameByDefault,
+		FuncMap:               opts.FuncMap,
+		rawEnvVars:            opts.rawEnvVars,
+	}
+}
+
+// Parse parses a struct containing `env` tags and loads its values from
+// environment variables.
+func Parse(v interface{}) error {
+	return parseInternal(v, setField, defaultOptions())
+}
+
+// ParseWithOptions parses a struct containing `env` tags and loads its values from
+// environment variables.
+func ParseWithOptions(v interface{}, opts Options) error {
+	return parseInternal(v, setField, customOptions(opts))
+}
+
+// GetFieldParams parses a struct containing `env` tags and returns information about
+// tags it found.
+func GetFieldParams(v interface{}) ([]FieldParams, error) {
+	return GetFieldParamsWithOptions(v, defaultOptions())
+}
+
+// GetFieldParamsWithOptions parses a struct containing `env` tags and returns information about
+// tags it found.
+func GetFieldParamsWithOptions(v interface{}, opts Options) ([]FieldParams, error) {
+	var result []FieldParams
+	err := parseInternal(
+		v,
+		func(_ reflect.Value, _ reflect.StructField, _ Options, fieldParams FieldParams) error {
+			if fieldParams.OwnKey != "" {
+				result = append(result, fieldParams)
+			}
+			return nil
+		},
+		customOptions(opts),
+	)
+	if err != nil {
+		return nil, err
+	}
+
+	return result, nil
+}
+
+func parseInternal(v interface{}, processField processFieldFn, opts Options) error {
+	ptrRef := reflect.ValueOf(v)
+	if ptrRef.Kind() != reflect.Ptr {
+		return newAggregateError(NotStructPtrError{})
+	}
+	ref := ptrRef.Elem()
+	if ref.Kind() != reflect.Struct {
+		return newAggregateError(NotStructPtrError{})
+	}
+
+	return doParse(ref, processField, opts)
+}
+
+func doParse(ref reflect.Value, processField processFieldFn, opts Options) error {
+	refType := ref.Type()
+
+	var agrErr AggregateError
+
+	for i := 0; i < refType.NumField(); i++ {
+		refField := ref.Field(i)
+		refTypeField := refType.Field(i)
+
+		if err := doParseField(refField, refTypeField, processField, opts); err != nil {
+			if val, ok := err.(AggregateError); ok {
+				agrErr.Errors = append(agrErr.Errors, val.Errors...)
+			} else {
+				agrErr.Errors = append(agrErr.Errors, err)
+			}
+		}
+	}
+
+	if len(agrErr.Errors) == 0 {
+		return nil
+	}
+
+	return agrErr
+}
+
+func doParseField(refField reflect.Value, refTypeField reflect.StructField, processField processFieldFn, opts Options) error {
+	if !refField.CanSet() {
+		return nil
+	}
+	if reflect.Ptr == refField.Kind() && !refField.IsNil() {
+		return parseInternal(refField.Interface(), processField, optionsWithEnvPrefix(refTypeField, opts))
+	}
+	if reflect.Struct == refField.Kind() && refField.CanAddr() && refField.Type().Name() == "" {
+		return parseInternal(refField.Addr().Interface(), processField, optionsWithEnvPrefix(refTypeField, opts))
+	}
+
+	params, err := parseFieldParams(refTypeField, opts)
+	if err != nil {
+		return err
+	}
+
+	if err := processField(refField, refTypeField, opts, params); err != nil {
+		return err
+	}
+
+	if reflect.Struct == refField.Kind() {
+		return doParse(refField, processField, optionsWithEnvPrefix(refTypeField, opts))
+	}
+
+	return nil
+}
+
+func setField(refField reflect.Value, refTypeField reflect.StructField, opts Options, fieldParams FieldParams) error {
+	value, err := get(fieldParams, opts)
+	if err != nil {
+		return err
+	}
+
+	if value != "" {
+		return set(refField, refTypeField, value, opts.FuncMap)
+	}
+
+	return nil
+}
+
+const underscore rune = '_'
+
+func toEnvName(input string) string {
+	var output []rune
+	for i, c := range input {
+		if i > 0 && output[i-1] != underscore && c != underscore && unicode.ToUpper(c) == c {
+			output = append(output, underscore)
+		}
+		output = append(output, unicode.ToUpper(c))
+	}
+	return string(output)
+}
+
+// FieldParams contains information about parsed field tags.
+type FieldParams struct {
+	OwnKey          string
+	Key             string
+	DefaultValue    string
+	HasDefaultValue bool
+	Required        bool
+	LoadFile        bool
+	Unset           bool
+	NotEmpty        bool
+	Expand          bool
+}
+
+func parseFieldParams(field reflect.StructField, opts Options) (FieldParams, error) {
+	ownKey, tags := parseKeyForOption(field.Tag.Get(opts.TagName))
+	if ownKey == "" && opts.UseFieldNameByDefault {
+		ownKey = toEnvName(field.Name)
+	}
+
+	defaultValue, hasDefaultValue := field.Tag.Lookup("envDefault")
+
+	result := FieldParams{
+		OwnKey:          ownKey,
+		Key:             opts.Prefix + ownKey,
+		Required:        opts.RequiredIfNoDef,
+		DefaultValue:    defaultValue,
+		HasDefaultValue: hasDefaultValue,
+	}
+
+	for _, tag := range tags {
+		switch tag {
+		case "":
+			continue
+		case "file":
+			result.LoadFile = true
+		case "required":
+			result.Required = true
+		case "unset":
+			result.Unset = true
+		case "notEmpty":
+			result.NotEmpty = true
+		case "expand":
+			result.Expand = true
+		default:
+			return FieldParams{}, newNoSupportedTagOptionError(tag)
+		}
+	}
+
+	return result, nil
+}
+
+func get(fieldParams FieldParams, opts Options) (val string, err error) {
+	var exists, isDefault bool
+
+	val, exists, isDefault = getOr(fieldParams.Key, fieldParams.DefaultValue, fieldParams.HasDefaultValue, opts.Environment)
+
+	if fieldParams.Expand {
+		val = os.Expand(val, opts.getRawEnv)
+	}
+
+	opts.rawEnvVars[fieldParams.OwnKey] = val
+
+	if fieldParams.Unset {
+		defer os.Unsetenv(fieldParams.Key)
+	}
+
+	if fieldParams.Required && !exists && len(fieldParams.OwnKey) > 0 {
+		return "", newEnvVarIsNotSet(fieldParams.Key)
+	}
+
+	if fieldParams.NotEmpty && val == "" {
+		return "", newEmptyEnvVarError(fieldParams.Key)
+	}
+
+	if fieldParams.LoadFile && val != "" {
+		filename := val
+		val, err = getFromFile(filename)
+		if err != nil {
+			return "", newLoadFileContentError(filename, fieldParams.Key, err)
+		}
+	}
+
+	if opts.OnSet != nil {
+		if fieldParams.OwnKey != "" {
+			opts.OnSet(fieldParams.Key, val, isDefault)
+		}
+	}
+	return val, err
+}
+
+// split the env tag's key into the expected key and desired option, if any.
+func parseKeyForOption(key string) (string, []string) {
+	opts := strings.Split(key, ",")
+	return opts[0], opts[1:]
+}
+
+func getFromFile(filename string) (value string, err error) {
+	b, err := os.ReadFile(filename)
+	return string(b), err
+}
+
+func getOr(key, defaultValue string, defExists bool, envs map[string]string) (val string, exists bool, isDefault bool) {
+	value, exists := envs[key]
+	switch {
+	case (!exists || key == "") && defExists:
+		return defaultValue, true, true
+	case exists && value == "" && defExists:
+		return defaultValue, true, true
+	case !exists:
+		return "", false, false
+	}
+
+	return value, true, false
+}
+
+func set(field reflect.Value, sf reflect.StructField, value string, funcMap map[reflect.Type]ParserFunc) error {
+	if tm := asTextUnmarshaler(field); tm != nil {
+		if err := tm.UnmarshalText([]byte(value)); err != nil {
+			return newParseError(sf, err)
+		}
+		return nil
+	}
+
+	typee := sf.Type
+	fieldee := field
+	if typee.Kind() == reflect.Ptr {
+		typee = typee.Elem()
+		fieldee = field.Elem()
+	}
+
+	parserFunc, ok := funcMap[typee]
+	if ok {
+		val, err := parserFunc(value)
+		if err != nil {
+			return newParseError(sf, err)
+		}
+
+		fieldee.Set(reflect.ValueOf(val))
+		return nil
+	}
+
+	parserFunc, ok = defaultBuiltInParsers[typee.Kind()]
+	if ok {
+		val, err := parserFunc(value)
+		if err != nil {
+			return newParseError(sf, err)
+		}
+
+		fieldee.Set(reflect.ValueOf(val).Convert(typee))
+		return nil
+	}
+
+	switch field.Kind() {
+	case reflect.Slice:
+		return handleSlice(field, value, sf, funcMap)
+	case reflect.Map:
+		return handleMap(field, value, sf, funcMap)
+	}
+
+	return newNoParserError(sf)
+}
+
+func handleSlice(field reflect.Value, value string, sf reflect.StructField, funcMap map[reflect.Type]ParserFunc) error {
+	separator := sf.Tag.Get("envSeparator")
+	if separator == "" {
+		separator = ","
+	}
+	parts := strings.Split(value, separator)
+
+	typee := sf.Type.Elem()
+	if typee.Kind() == reflect.Ptr {
+		typee = typee.Elem()
+	}
+
+	if _, ok := reflect.New(typee).Interface().(encoding.TextUnmarshaler); ok {
+		return parseTextUnmarshalers(field, parts, sf)
+	}
+
+	parserFunc, ok := funcMap[typee]
+	if !ok {
+		parserFunc, ok = defaultBuiltInParsers[typee.Kind()]
+		if !ok {
+			return newNoParserError(sf)
+		}
+	}
+
+	result := reflect.MakeSlice(sf.Type, 0, len(parts))
+	for _, part := range parts {
+		r, err := parserFunc(part)
+		if err != nil {
+			return newParseError(sf, err)
+		}
+		v := reflect.ValueOf(r).Convert(typee)
+		if sf.Type.Elem().Kind() == reflect.Ptr {
+			v = reflect.New(typee)
+			v.Elem().Set(reflect.ValueOf(r).Convert(typee))
+		}
+		result = reflect.Append(result, v)
+	}
+	field.Set(result)
+	return nil
+}
+
+func handleMap(field reflect.Value, value string, sf reflect.StructField, funcMap map[reflect.Type]ParserFunc) error {
+	keyType := sf.Type.Key()
+	keyParserFunc, ok := funcMap[keyType]
+	if !ok {
+		keyParserFunc, ok = defaultBuiltInParsers[keyType.Kind()]
+		if !ok {
+			return newNoParserError(sf)
+		}
+	}
+
+	elemType := sf.Type.Elem()
+	elemParserFunc, ok := funcMap[elemType]
+	if !ok {
+		elemParserFunc, ok = defaultBuiltInParsers[elemType.Kind()]
+		if !ok {
+			return newNoParserError(sf)
+		}
+	}
+
+	separator := sf.Tag.Get("envSeparator")
+	if separator == "" {
+		separator = ","
+	}
+
+	keyValSeparator := sf.Tag.Get("envKeyValSeparator")
+	if keyValSeparator == "" {
+		keyValSeparator = ":"
+	}
+
+	result := reflect.MakeMap(sf.Type)
+	for _, part := range strings.Split(value, separator) {
+		pairs := strings.Split(part, keyValSeparator)
+		if len(pairs) != 2 {
+			return newParseError(sf, fmt.Errorf(`%q should be in "key%svalue" format`, part, keyValSeparator))
+		}
+
+		key, err := keyParserFunc(pairs[0])
+		if err != nil {
+			return newParseError(sf, err)
+		}
+
+		elem, err := elemParserFunc(pairs[1])
+		if err != nil {
+			return newParseError(sf, err)
+		}
+
+		result.SetMapIndex(reflect.ValueOf(key).Convert(keyType), reflect.ValueOf(elem).Convert(elemType))
+	}
+
+	field.Set(result)
+	return nil
+}
+
+func asTextUnmarshaler(field reflect.Value) encoding.TextUnmarshaler {
+	if reflect.Ptr == field.Kind() {
+		if field.IsNil() {
+			field.Set(reflect.New(field.Type().Elem()))
+		}
+	} else if field.CanAddr() {
+		field = field.Addr()
+	}
+
+	tm, ok := field.Interface().(encoding.TextUnmarshaler)
+	if !ok {
+		return nil
+	}
+	return tm
+}
+
+func parseTextUnmarshalers(field reflect.Value, data []string, sf reflect.StructField) error {
+	s := len(data)
+	elemType := field.Type().Elem()
+	slice := reflect.MakeSlice(reflect.SliceOf(elemType), s, s)
+	for i, v := range data {
+		sv := slice.Index(i)
+		kind := sv.Kind()
+		if kind == reflect.Ptr {
+			sv = reflect.New(elemType.Elem())
+		} else {
+			sv = sv.Addr()
+		}
+		tm := sv.Interface().(encoding.TextUnmarshaler)
+		if err := tm.UnmarshalText([]byte(v)); err != nil {
+			return newParseError(sf, err)
+		}
+		if kind == reflect.Ptr {
+			slice.Index(i).Set(sv)
+		}
+	}
+
+	field.Set(slice)
+
+	return nil
+}
+
+// ToMap Converts list of env vars as provided by os.Environ() to map you
+// can use as Options.Environment field
+func ToMap(env []string) map[string]string {
+	return toMap(env)
+}

vendor/github.com/caarlos0/env/v10/env_tomap.go

@@ -0,0 +1,16 @@
+//go:build !windows
+
+package env
+
+import "strings"
+
+func toMap(env []string) map[string]string {
+	r := map[string]string{}
+	for _, e := range env {
+		p := strings.SplitN(e, "=", 2)
+		if len(p) == 2 {
+			r[p[0]] = p[1]
+		}
+	}
+	return r
+}

vendor/github.com/caarlos0/env/v10/env_tomap_windows.go

@@ -0,0 +1,29 @@
+//go:build windows
+
+package env
+
+import "strings"
+
+func toMap(env []string) map[string]string {
+	r := map[string]string{}
+	for _, e := range env {
+		p := strings.SplitN(e, "=", 2)
+
+		// On Windows, environment variables can start with '='. If so, Split at next character.
+		// See env_windows.go in the Go source: https://github.com/golang/go/blob/master/src/syscall/env_windows.go#L58
+		prefixEqualSign := false
+		if len(e) > 0 && e[0] == '=' {
+			e = e[1:]
+			prefixEqualSign = true
+		}
+		p = strings.SplitN(e, "=", 2)
+		if prefixEqualSign {
+			p[0] = "=" + p[0]
+		}
+
+		if len(p) == 2 {
+			r[p[0]] = p[1]
+		}
+	}
+	return r
+}

vendor/github.com/caarlos0/env/v10/error.go

@@ -0,0 +1,164 @@
+package env
+
+import (
+	"fmt"
+	"reflect"
+	"strings"
+)
+
+// An aggregated error wrapper to combine gathered errors. This allows either to display all errors or convert them individually
+// List of the available errors
+// ParseError
+// NotStructPtrError
+// NoParserError
+// NoSupportedTagOptionError
+// EnvVarIsNotSetError
+// EmptyEnvVarError
+// LoadFileContentError
+// ParseValueError
+type AggregateError struct {
+	Errors []error
+}
+
+func newAggregateError(initErr error) error {
+	return AggregateError{
+		[]error{
+			initErr,
+		},
+	}
+}
+
+func (e AggregateError) Error() string {
+	var sb strings.Builder
+
+	sb.WriteString("env:")
+
+	for _, err := range e.Errors {
+		sb.WriteString(fmt.Sprintf(" %v;", err.Error()))
+	}
+
+	return strings.TrimRight(sb.String(), ";")
+}
+
+// Is conforms with errors.Is.
+func (e AggregateError) Is(err error) bool {
+	for _, ie := range e.Errors {
+		if reflect.TypeOf(ie) == reflect.TypeOf(err) {
+			return true
+		}
+	}
+	return false
+}
+
+// The error occurs when it's impossible to convert the value for given type.
+type ParseError struct {
+	Name string
+	Type reflect.Type
+	Err  error
+}
+
+func newParseError(sf reflect.StructField, err error) error {
+	return ParseError{sf.Name, sf.Type, err}
+}
+
+func (e ParseError) Error() string {
+	return fmt.Sprintf(`parse error on field "%s" of type "%s": %v`, e.Name, e.Type, e.Err)
+}
+
+// The error occurs when pass something that is not a pointer to a Struct to Parse
+type NotStructPtrError struct{}
+
+func (e NotStructPtrError) Error() string {
+	return "expected a pointer to a Struct"
+}
+
+// This error occurs when there is no parser provided for given type
+// Supported types and defaults: https://github.com/caarlos0/env#supported-types-and-defaults
+// How to create a custom parser: https://github.com/caarlos0/env#custom-parser-funcs
+type NoParserError struct {
+	Name string
+	Type reflect.Type
+}
+
+func newNoParserError(sf reflect.StructField) error {
+	return NoParserError{sf.Name, sf.Type}
+}
+
+func (e NoParserError) Error() string {
+	return fmt.Sprintf(`no parser found for field "%s" of type "%s"`, e.Name, e.Type)
+}
+
+// This error occurs when the given tag is not supported
+// In-built supported tags: "", "file", "required", "unset", "notEmpty", "expand", "envDefault", "envSeparator"
+// How to create a custom tag: https://github.com/caarlos0/env#changing-default-tag-name
+type NoSupportedTagOptionError struct {
+	Tag string
+}
+
+func newNoSupportedTagOptionError(tag string) error {
+	return NoSupportedTagOptionError{tag}
+}
+
+func (e NoSupportedTagOptionError) Error() string {
+	return fmt.Sprintf("tag option %q not supported", e.Tag)
+}
+
+// This error occurs when the required variable is not set
+// Read about required fields: https://github.com/caarlos0/env#required-fields
+type EnvVarIsNotSetError struct {
+	Key string
+}
+
+func newEnvVarIsNotSet(key string) error {
+	return EnvVarIsNotSetError{key}
+}
+
+func (e EnvVarIsNotSetError) Error() string {
+	return fmt.Sprintf(`required environment variable %q is not set`, e.Key)
+}
+
+// This error occurs when the variable which must be not empty is existing but has an empty value
+// Read about not empty fields: https://github.com/caarlos0/env#not-empty-fields
+type EmptyEnvVarError struct {
+	Key string
+}
+
+func newEmptyEnvVarError(key string) error {
+	return EmptyEnvVarError{key}
+}
+
+func (e EmptyEnvVarError) Error() string {
+	return fmt.Sprintf("environment variable %q should not be empty", e.Key)
+}
+
+// This error occurs when it's impossible to load the value from the file
+// Read about From file feature: https://github.com/caarlos0/env#from-file
+type LoadFileContentError struct {
+	Filename string
+	Key      string
+	Err      error
+}
+
+func newLoadFileContentError(filename, key string, err error) error {
+	return LoadFileContentError{filename, key, err}
+}
+
+func (e LoadFileContentError) Error() string {
+	return fmt.Sprintf(`could not load content of file "%s" from variable %s: %v`, e.Filename, e.Key, e.Err)
+}
+
+// This error occurs when it's impossible to convert value using given parser
+// Supported types and defaults: https://github.com/caarlos0/env#supported-types-and-defaults
+// How to create a custom parser: https://github.com/caarlos0/env#custom-parser-funcs
+type ParseValueError struct {
+	Msg string
+	Err error
+}
+
+func newParseValueError(message string, err error) error {
+	return ParseValueError{message, err}
+}
+
+func (e ParseValueError) Error() string {
+	return fmt.Sprintf("%s: %v", e.Msg, e.Err)
+}

vendor/modules.txt

@@ -0,0 +1,3 @@
+# github.com/caarlos0/env/v10 v10.0.0
+## explicit; go 1.17
+github.com/caarlos0/env/v10