GConf
Global Configuration for the masses.
GConf
const gconf_instance = ;
The GConf
Object is the base and main API for the library.
The constructor for the class can register modifiers and providers (Note currenty there can be only one provider) from the options object.
options
provider: ...providerOptions modifierA: true modifierB: ...modifierOptions
The options object is based by the key being the Name of the provider or modifier, and the Object being the options Object for the provider's/modifier's constructor.
example config for creating a memory provider with an env modifier:
memory: dev: foo: 'bar' prod: foo: 'bar2000' env: prefix: 'CONF'
this gives me a object { foo: 'bar' }
for requesting dev and { foo: 'bar2000' }
for prod.
GConf.get(domain, path)
this is the function to use to get the data from the config, meaning (with the example config above) you will get
gconf_instance // { foo: 'bar' } gconf_instance // 'bar'
domain
is the domain (maybe env or any other generlisation) where to look, defined in provider's constructor (options)
path
is for geting specific parts of the config and not the entire thing
GConf.meta
This is a meta-options for gconf, for example the default domain when none is given
gconf.registerProvider(provider, options)
& gconf.registerModifier(modifier, options)
Are a way to register modifiers and providers not in the constructor
GConf.default
Allows to acess functions with default domain, this defaults to 'default' =|
// lets say in our domain named 'default' has { foo: 'bar' } gconf_instance; // -> 'bar'gconf_instancedefault; // -> 'bar' and if we change it to 'dev' it should be like: gconf_instancemetadefault_domain = 'dev'; gconf_instance === gconf_instancedefault;
Singleton Registration
The library implements a singleton factory to save the loaded config.
var options = // ... gconf_instance = options; gconf; // The 'load' will retrive ither GConf instance gconf; // or the constructor params for the GConf instance
and then you can access it from any part the application
var gconf = ; gconfinstance // == a gconf instance created in 'load'.
.gconfrc
Gconf can get the initial configuration for the singleton instance from a .gconfrc file (it's a json) aswell as external plugin loading
With .gconfrc you can use require('gconf/default'); // The same as require('gconf').instance.default
Providers
Memory Provider
Made to load configuration from an object.
provider name: memory
memory: domain: ...objectForEnvConfig
returns the object corresponding to the requested domain
File Provider
File based fetching of config with json
and yaml
support
provider name: file
file: dev: path: './config.dev.json' watch: true prod: path: './config.prod.json' watch: false
Will load yaml and json files and watch
will keep them up to date
Modifiers
Env Modifier
modifies the base config with Enviroment Variables
modifier name: env
{prefix}{splitter}{path}
example:
GCONF_a_b_c = 'd' => { a: { b: { c: 'd' } } }
/// when GCONF is prefix and '_' is splitter
Splitter and Prefix are defined in the modifier's constructor
Argv Modifier
modifies the base config with the arguments provided in run
modifier name: argv
the splitter is .
so:
node test.js --foo.bar=2000 // config =>
Extend API
Creating modifier / provider
There are two classes in gconf.components
, the Modifier
and Provider
classes are the base classes for all providers and modifiers accordingly
By extending the base class you can create modifiers or providers
// Override the base function { // domain is the config domain, and the path is a path to get to the specified value, both are optional }
then after creating a class you need to regiter it, this you do through the components.registerProvider('newProvider', NewProvider)
and components.registerModifier('newMofifier', NewMofifier)
where you need to send the name and class (keep in mind, the class and not an instance). After registration you can use it like every other provider/modifier
Credits
Created by Dmitry Dodzin under MIT license.