Ecosyste.ms: Awesome
An open API service indexing awesome lists of open source software.
https://github.com/tanvd/konfy
Statically typed configurations for Kotlin
https://github.com/tanvd/konfy
config configuration keepass kotlin ssm toml
Last synced: 3 months ago
JSON representation
Statically typed configurations for Kotlin
- Host: GitHub
- URL: https://github.com/tanvd/konfy
- Owner: TanVD
- Created: 2019-05-30T09:28:59.000Z (over 5 years ago)
- Default Branch: master
- Last Pushed: 2024-07-24T16:50:51.000Z (6 months ago)
- Last Synced: 2024-07-24T19:30:46.723Z (6 months ago)
- Topics: config, configuration, keepass, kotlin, ssm, toml
- Language: Kotlin
- Homepage:
- Size: 352 KB
- Stars: 9
- Watchers: 2
- Forks: 1
- Open Issues: 4
-
Metadata Files:
- Readme: README.md
Awesome Lists containing this project
README
# Konfy
Konfy is a statically typed and easy to use configuration library for Kotlin.
The main idea of Konfy is **chains** and **views** - you are creating a **chain**
of configs to retrieve parameters from different storage through one interface; after
it you can create **view** - a typeful interface to config parameters.
Konfy supports plenty of formats with corresponding providers:
* Environment variables (out of the box) - support of environment variables
* System properties (out of the box) - support of system properties
* JNDI resources (out of the box) - support of JNDI resources in different contexts
* Property files (out of the box) - support of property files
* TOML (konfy-toml) - support of TOML
* SSM (konfy-ssm) - support of AWS Simple System Manager parameters
* KeePass (konfy-keepass) - support of parameters stored in kdbx encrypted files
* Kara config (konfy-kara) - support of properties config with includes (Kara framework config)
## Setup
To set it up, add a library to compile dependencies:
```kotlin
repositories {
maven(url = "https://packages.jetbrains.team/maven/p/konfy/maven")
}
dependencies {
compile("tanvd.konfy", "konfy", "0.1.23")
//Other necessary providers
}
```
## What's inside
### Providers
First, you will need to create `ConfigProvider` object.
`ConfigProvider` can be asked directly for a config parameter via `get` call.
```kotlin
//Instantiation of EnvVarProvider with implicit default conversion service
val envVar = EnvVarProvider()
//Get value from a provider with explicit default value
val value = envVar.get("value", default = 5)
```
#### Conversions
Almost all providers (excluding JNDI) include a parameter in a constructor
for a conversion function. This function will be used to convert values from
string representation to specific type.
Conversion is needed only if a specific configuration format does not support
such type of parameters, and it should be deserialized from text representation.
Konfy assumes the following formats of values:
* Boolean: true, false
* Integer: 1
* Double: 1.0
* String: "string"
* Array: [1, 2], ["1", "2"]
### Chaining
Few providers can be linked to a chain. Resolution of parameter will stop
once it's found in a provider inside a chain.
```kotlin
val chain = ConfigChain(EnvVarProvider, KeepassProvider)
```
### Views
Now you can create a view to a chain - it will provide you with a typeful interface
to a configuration.
```kotlin
object Config: ConfigView() {
/** Delegates to a `key` parameter in a config. No default. Will be cached. */
val key: String by provided()
/** Delegates to an `other-key` parameter in a config. Default is 0. Will be cached. */
val otherKey: Int by provided("other-key", 0)
/** Delegates to a `lastKey` parameter in a config. No default. Will not be cached. */
val lastKey: Int by provided("other-key", cached = false)
}
```
View can cache parameters and provide defaults for them.
### GlobalKonfy
`GlobalKonfy` object is basically a global configuration interface. You may initialize
it on the start of an application with a configuration chain and then use it everywhere to
get configuration parameters.
Moreover, `ConfigView` by default will take its `ConfigProvider` from `GlobalKonfy`
## Few advice
One of the interesting usages for Konfy is to split your configs
into a **secret** and *not-very-secret* and put secret config into KeePass DB (kdbx)
and not-very-secret into simple config file - for example, TOML. Chain will merge configs
together and View will provide one typeful interface to all parameters.