TypeScript icon, indicating that this package has built-in type declarations

    0.1.1 • Public • Published

    ⚙️ Api-Typed/Config

    🥣 An Api-Typed component.

    Simple configuration container.

    • Exports a global default instance.
    • But allows multiple instances.
    • Load configuration from objects, files (.ts, .js, .json) or dirs (all files from a directory).
    • Freeze to make sure no configuration can be overwritten at later time.
    • Reference config params inside other params.
    • Inject config params via @ConfigParam() decorator when combined with TypeDI.


    $ npm i -S @api-typed/config

    No configuration needed.


    The default export of the package is a default global instance of Config class. This is the most convenient way to use it (especially if you want to use @ConfigParam() decorator).

    Load configuration

    import Config from '@api-typed/config';
    // load an object directly
      database: {
        hostname: 'localhost',
        username: 'root',
        password: 'root',
        database: 'api_typed',
    // load config from a file
    // - the configuration object should be the default export
    // - you can omit extension to load TS or JS file
    // - also supports .json
    // load all config files from the given directory
    // - will load all TS, JS and JSON files
    // - the configuration object should be the default export from all files
    // you can freeze the config to prevent loading any more config params
    // useful when bootstrapping an app and you don't want something
    // randomly overwriting your configuration
    // will throw an error at this point

    Read configuration

    Once your configuration has been loaded you have multiple ways to read it.

    import Config from '@api-typed/config';
    // read config param (will read the whole object)
    const databaseConfig = Config.get('database');
    // you can use dot notation to access nested configuration
    const dbHost = Config.get('database.host');
    // you can type the return value
    const dbPassword = Config.get<string>('database.password');
    // you can specify a default value to return if the config param is missing
    const dbPort = Config.get<number>('database.port', 5432);
    // use `.getRequired()` to throw an error if the config param is missing
    const dbUsername = Config.getRequired<string>('database.username');
    // pass an array of property names that you expect to be set on the returned object
    // if any of them is null or undefined then it will throw
    const dbConfig = Config.getRequired('database', [

    Reference other config params

    Sometimes you may want to have config params that depend on other config params.

    The most common example are path configurations where they may depend on a single root dir:

    Let's say in entry point of your app you have:

    import Config from '@api-typed/config';
      rootDir: process.cwd(),

    Then you can have a configuration file e.g. log.config.ts:

    export default {
      log: {
        logDir: '<rootDir>/logs',
        outputs: {
          errorLog: '<logDir>/error.log',
          requestLog: '<logDir>/requests.log',

    When you retrieve log.outputs.errorLog config param it will be set to ${process.cwd()}/logs/error.log (where process.cwd() will of course resolve to your working dir).

    You can use dot notation when referencing other config params.

    Use @ConfigParam() decorator to inject values

    If your project uses TypeDI for a dependency injection container, you may want to inject configuration parameters into your services.

    import { ConfigParam } from '@api-typed/config';
    import { Service } from 'typedi';
    export class DatabaseService {
        private readonly hostname: string,
        private readonly username: string,
        private readonly password: string,
        @ConfigParam<number>('database.port', { optional: true })
        private readonly host: number = 5432,
      ) {}

    Create other instances of Config

    You can create more instance of the config if you wish so. Just use the exported Config class:

    import { Config } from '@api-typed/config';
    const myConfig = new Config();
      port: 3000,
    const myOtherConfig = new Config();
      port: 4000,
    myConfig.get('port'); // 3000
    myOtherConfig.get('port'); // 4000

    NOTE: @ConfigParam() doesn't have access to custom instances of the config, so you won't be able to use it.


    npm i @api-typed/config

    DownloadsWeekly Downloads






    Unpacked Size

    15.4 kB

    Total Files


    Last publish


    • michaldudek