aboutsummaryrefslogtreecommitdiffstats
path: root/internal/configloader/configloader.go
blob: 0f724a63f540654cbe6cbac6d59f8afbe5177bec (plain) (blame)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
// Package configloader implements a Config type for loading in the
// configuration to be used by the app.
//
// It supports reading in configuration from the "bolt.toml" file
// if it can be found in the current directory or any parent directory
// and it supports reading in environment variables. Furthermore, if
// both a configuration file is found and environment variables are set,
// the environment variables will take precedence.
package configloader

import (
	"errors"
	"fmt"
	"os"
	"path/filepath"
	"runtime"

	"github.com/BurntSushi/toml"
	"github.com/kelseyhightower/envconfig"
)

type VersionStyle string

const (
	VersionStyleSequential VersionStyle = "sequential"
	VersionStyleTimestamp  VersionStyle = "timestamp"
)

var (
	ErrConfigFileNotFound = errors.New(
		"bolt configuration file not found in current directory or any parent directories",
	)
	ErrInvalidVersionStyle = fmt.Errorf(
		"invalid version style for bolt migrations. supported styles: %v",
		[]VersionStyle{VersionStyleSequential, VersionStyleTimestamp},
	)
)

// Config represents the application configuration settings.
//
// This can come from the TOML file or environment variables,
// with environment variables taking precedence.
type Config struct {
	Migrations MigrationsConfig `toml:"migrations"`

	// Information related to how to connect to the database
	// that is desired to run migrations against.
	Connection ConnectionConfig `toml:"database"`
}

type MigrationsConfig struct {
	DirectoryPath string       `toml:"directory_path" envconfig:"BOLT_MIGRATIONS_DIR_PATH"`
	VersionStyle  VersionStyle `toml:"version_style"  envconfig:"BOLT_MIGRATIONS_VERSION_STYLE"`
}

type ConnectionConfig struct {
	Host            string `toml:"host"     envconfig:"BOLT_DB_HOST"`
	Port            string `toml:"port"     envconfig:"BOLT_DB_PORT"`
	User            string `toml:"user"     envconfig:"BOLT_DB_USER"`
	Password        string `toml:"password" envconfig:"BOLT_DB_PASSWORD"`
	DBName          string `toml:"dbname"   envconfig:"BOLT_DB_NAME"`
	Driver          string `toml:"driver"   envconfig:"BOLT_DB_DRIVER"`
	MigrationsTable string `toml:"migrations_table" envconfig:"BOLT_DB_MIGRATIONS_TABLE"`
}

func NewConfig() (*Config, error) {
	filePath, err := findConfigFilePath()
	if err != nil && !errors.Is(err, ErrConfigFileNotFound) {
		return nil, err
	}

	cfg := Config{
		Migrations: MigrationsConfig{
			DirectoryPath: "migrations",
			VersionStyle:  VersionStyleTimestamp,
		},
		Connection: ConnectionConfig{
			MigrationsTable: "bolt_migrations",
		},
	}
	if !errors.Is(err, ErrConfigFileNotFound) {
		_, err = toml.DecodeFile(filePath, &cfg)
		if err != nil {
			return nil, err
		}
	}

	err = envconfig.Process("", &cfg)
	if err != nil {
		return nil, err
	}

	if cfg.Migrations.VersionStyle != VersionStyleSequential &&
		cfg.Migrations.VersionStyle != VersionStyleTimestamp {
		return nil, ErrInvalidVersionStyle
	}

	return &cfg, nil
}

func findConfigFilePath() (filePath string, err error) {
	const configFileName = "bolt.toml"
	var rootDir = fsRootDir()

	dir, err := os.Getwd()
	if err != nil {
		return "", err
	}

	for {
		entries, err := os.ReadDir(dir)
		if err != nil {
			return "", err
		}

		for _, e := range entries {
			if e.Name() == configFileName {
				return filepath.Join(dir, e.Name()), nil
			}
		}

		if dir == rootDir {
			return "", ErrConfigFileNotFound
		}

		dir = filepath.Dir(dir)
	}
}

// fsRootDir retrieves the root directory
// of the filesystem on Windows or any unix-like
// operating system.
func fsRootDir() string {
	if runtime.GOOS == "windows" {
		return os.Getenv("SystemDrive")
	}
	return "/"
}