rc

What is rc?

The rc npm package is a configuration loader for Node.js applications. It allows you to configure your applications with files, environment variables, and command-line arguments. This package is particularly useful for creating flexible applications that can be easily configured without changing the codebase.

What are rc's main functionalities?

Loading configuration from a file

This feature allows you to load configuration for your application named 'appname' from a file. If the file does not exist, it falls back to the default configuration provided.

const config = require('rc')('appname', { defaultConfig: 'defaultValue' });

Overriding configuration with environment variables

This demonstrates how to override a specific configuration option ('configOption') for 'appname' using an environment variable. The environment variable takes precedence over the default value.

process.env.appname_configOption = 'newValue';
const config = require('rc')('appname', { configOption: 'defaultValue' });

Using command-line arguments to override configuration

This example shows how command-line arguments can be used to override the configuration in 'appname'. The command-line argument '--configOption newValue' overrides the default configuration.

// Run the application with: node app.js --configOption newValue
const config = require('rc')('appname', { configOption: 'defaultValue' });

Other packages similar to rc

config

Similar to rc, the 'config' package is used for managing configuration settings for Node.js applications. It supports loading configurations from files and environment variables. Compared to rc, 'config' provides a more structured approach to defining default configurations and environment-specific overrides.

dotenv

The 'dotenv' package is focused on loading environment variables from a .env file into process.env, providing a simple way to manage configuration settings. Unlike rc, dotenv does not support loading configurations from command-line arguments or merging configurations from multiple sources.

nconf

nconf is a hierarchical configuration management library for Node.js. It supports loading configuration from files, environment variables, command-line arguments, and even remote storage. nconf offers a more complex API compared to rc but provides greater flexibility in managing configurations from multiple sources.

README

rc

The non-configurable configuration loader for lazy people.

Usage

The only option is to pass rc the name of your app, and your default configuration.

var conf = require('rc')(appname, {
  //defaults go here.
  port: 2468,

  //defaults which are objects will be merged, not replaced
  views: {
    engine: 'jade'
  }
});

rc will return your configuration options merged with the defaults you specify. If you pass in a predefined defaults object, it will be mutated:

var conf = {};
require('rc')(appname, conf);

If rc finds any config files for your app, the returned config object will have a configs array containing their paths:

var appCfg = require('rc')(appname, conf);
appCfg.configs[0] // /etc/appnamerc
appCfg.configs[1] // /home/dominictarr/.config/appname
appCfg.config // same as appCfg.configs[appCfg.configs.length - 1]

Standards

Given your application name (appname), rc will look in all the obvious places for configuration.

• command line arguments (parsed by minimist)
• environment variables prefixed with ${appname}_
  • or use "__" to indicate nested properties
    (e.g. appname_foo__bar__baz => foo.bar.baz)
• if you passed an option --config file then from that file
• a local .${appname}rc or the first found looking in ./ ../ ../../ ../../../ etc.
• $HOME/.${appname}rc
• $HOME/.${appname}/config
• $HOME/.config/${appname}
• $HOME/.config/${appname}/config
• /etc/${appname}rc
• /etc/${appname}/config
• the defaults object you passed in.

All configuration sources that were found will be flattened into one object, so that sources earlier in this list override later ones.

Configuration File Formats

Configuration files (e.g. .appnamerc) may be in either json or ini format. The example configurations below are equivalent:

Formatted as ini

; You can include comments in `ini` format if you want.

dependsOn=0.10.0


; `rc` has built-in support for ini sections, see?

[commands]
  www     = ./commands/www
  console = ./commands/repl


; You can even do nested sections

[generators.options]
  engine  = ejs

[generators.modules]
  new     = generate-new
  engine  = generate-backend

Formatted as json

{
  // You can even comment your JSON, if you want
  "dependsOn": "0.10.0",
  "commands": {
    "www": "./commands/www",
    "console": "./commands/repl"
  },
  "generators": {
    "options": {
      "engine": "ejs"
    },
    "modules": {
      "new": "generate-new",
      "backend": "generate-backend"
    }
  }
}

Comments are stripped from JSON config via strip-json-comments.

Since ini, and env variables do not have a standard for types, your application needs be prepared for strings.

Advanced Usage

Pass in your own argv

You may pass in your own argv as the third argument to rc. This is in case you want to use your own command-line opts parser.

require('rc')(appname, defaults, customArgvParser);

Pass in your own parser

If you have a special need to use a non-standard parser, you can do so by passing in the parser as the 4th argument. (leave the 3rd as null to get the default args parser)

require('rc')(appname, defaults, null, parser);

This may also be used to force a more strict format, such as strict, valid JSON only.

Note on Performance

rc is running fs.statSync-- so make sure you don't use it in a hot code path (e.g. a request handler)

License

BSD / MIT / Apache2