Make all properties of a class configurable using only one decorator!. 

Make all properties of a class configurable using only one decorator!

derbenoo

ts-configurable

- In case a property is an object create a new instance of that object instead of using a POJO (https://github.com/derbenoo/ts-configurable/issues/37)

- Fix a bug where non-ciphertext string values where set to null with setNullOnDecryptionFailure=true

- Breaking changes: options object for decryption changed: from `decryptionSecrets` to `decryption`: `secrets`, `setNullOnDecryptionFailure`

- Implement setNullOnDecryptionFailure flag

- Breaking changes: values are base64 encoded before being encrypted and base64 decoded after being decrypted. This way, when providing multiple keys, a correct decryption can be determined by checking whether the plaintext only contains charactesr from the base64 characterset.

- Export the `decrypt` method from the package so the consumer can test the correct functionality of encryption and decryption.

- Fixed error during packaging/ publishing which made the package unusable.

- Add the `decrypt` option for specifying decryption secrets that are used to decrypt configuration values that are provided encrypted.

- Add the `strictObjectStructureChecking` option

- Bugfix: remove the "is-plain-object" dependency and replace it with a simple object check as class instances should be treated as objects as well but are not "plain" objects

- Add example for a NestJS webserver using the ts-configurable package

- Additionally export IDecoratorOptions and IEnvOptions from package

- Introduce CI tools (CircleCI, Greenkeeper, Codecov)

Object.defineProperty(exports, "__esModule", { value: true });

const encryption_utils_1 = require("./encryption-utils");

 * Check whether a given value is a Javascript object

    return (val !== null && val !== undefined && typeof val === 'object' && Array.isArray(val) === false);

 * Assign values to an object based on a template object's properties and their respective types

 * @param obj Object to set the properties on

 * @param template Template object which is used to determine which properties should be set on the object and of what type those properties are

 * @param config Config object containing all values for the properties to be set for the object

 * @param parent Contains the current nested position in the object using the nested object dot notation (e.g. "obj1.nestedobj2.obj3"), used for error messages only

function assignValuesByTemplate(obj, template, config, options, decryption, parent) {

    Object.keys(template).forEach(key => {

        const templateValue = template[key];

                value = encryption_utils_1.attemptDecryption(decryption.keys, value);

                // Decryption was not successful

                if (decryption.setNullOnDecryptionFailure) {

                obj[key] = new templateValue.constructor();

                assignValuesByTemplate(obj[key], templateValue, value, options, decryption, `${parent}.${key}`);

            else if (!options.strictObjectStructureChecking) {

                throw new TypeError(`Property '${parent}.${key}' is of type object but a non-object value ('${JSON.stringify(value)}') was assigned!`);

        else if (Array.isArray(templateValue)) {

                if (options.enforceReadonly) {

                    Object.freeze(value);

                throw new TypeError(`Property '${parent}.${key}' is of type array but a non-array value ('${JSON.stringify(value)}') was assigned!`);

        else if (templateValue === null || templateValue === undefined) {

            // No type given by template property -> all primitive types are allowed

            if (typeof value !== 'object' || value === null) {

                throw new TypeError(`Property '${parent}.${key}' is of type null or undefined but a non-primitive value ('${JSON.stringify(value)}') was assigned!`);

            // Template property is a primitive type -> make sure value is a primitive type as well

                if (!options.strictTypeChecking || typeof templateValue === typeof value) {

                    throw new TypeError(`Property '${parent}.${key}' is of type ${typeof templateValue} but a value of type ${typeof value} ('${JSON.stringify(value)}') was assigned!`);

                throw new TypeError(`Property '${parent}.${key}' is of type ${typeof templateValue} but a non-primitive value ('${JSON.stringify(value)}') was assigned!`);

exports.assignValuesByTemplate = assignValuesByTemplate;

  "author": "Benjamin Assadsolimani (derbenoo)",

  "description": "Make all properties of a class configurable using only one decorator!",

    "url": "git@github.com:derbenoo/ts-configurable.git"

    "url": "https://github.com/derbenoo/ts-configurable/issues"

  "homepage": "https://github.com/derbenoo/ts-configurable",

[![npm](https://img.shields.io/npm/v/ts-configurable.svg?color=007acc)](https://www.npmjs.com/package/ts-configurable) [![GitHub](https://img.shields.io/github/license/derbenoo/ts-configurable.svg?color=007acc)](https://github.com/derbenoo/ts-configurable/blob/master/LICENSE) [![npm bundle size](https://img.shields.io/bundlephobia/min/ts-configurable.svg?color=007acc)](https://www.npmjs.com/package/ts-configurable)

[![Snyk Vulnerabilities for npm package](https://img.shields.io/snyk/vulnerabilities/npm/ts-configurable.svg)](https://snyk.io/test/npm/ts-configurable) [![CircleCI (all branches)](https://img.shields.io/circleci/project/github/derbenoo/ts-configurable.svg)](https://circleci.com/gh/derbenoo/ts-configurable) [![Codecov](https://img.shields.io/codecov/c/gh/derbenoo/ts-configurable.svg)](https://codecov.io/gh/derbenoo/ts-configurable)

:sparkles: **Make all properties of a class configurable using only one decorator!** :sparkles:

Let's be real, configuration is not sexy. We all just want to set up our project's configuration as easily as possible and then move on to build whatever we _actually_ wanted to build. But what if I told you that you can meet all your configuration needs with a single line of code and then never have to worry about it again?

Let's be real, configuration is no fun. We all just want to set up our project's configuration as easily as possible and then move on to build whatever we _actually_ wanted to build. But what if I told you that you can meet all your configuration needs with a single line of code and then never have to worry about it again?

Simply create a class defining all configuration properties, tack on the `@Configurable()` decorator and off you go! Take advantage of type-safety, environment variable loading, command line argument parsing and much more right out-of-the-box.

Install via `npm i ts-configurable` and create a config class with default values for each property:

import { Configurable } from 'ts-configurable';

Due to the `@Configurable()` decorator, the values for all properties can now be set via environment variables or command line arguments:

ServerConfig { host: 'localhost', port: 3000 }

ServerConfig { host: 'localhost', port: 4200 }

ServerConfig { host: '0.0.0.0', port: 3000 }

# Throw an error if a value with a different type was assigned

TypeError: Property 'ServerConfig.port' is of type number but a value of type string ('"random"') was assigned!

  - No need to maintain a separate TypeScript interface

  - Types can be infered from the property's default value

  - Enforce correct types for values passed by environment variables and command line arguments (`strictTypeChecking` option)

- Take advantage of having a configuration class:

  - Calculate config values based on other config values (e.g. `url` from `host` and `port`)

  - Getter functions (e.g. `get debugPort() { return this.port + 1000; }`)

  - Inherit from other configuration classes

- Enforce configuration values to be read-only at compile time ([readonly modifier](https://www.typescriptlang.org/docs/handbook/classes.html#readonly-modifier)) and at runtime (`enforceReadonly` option)

- Load environment variables from a local file (using [dotenv](https://www.npmjs.com/package/dotenv/v/6.2.0))

**Configurable**(options?: `IDecoratorOptions`)

Class decorator for marking a class configurable: The values of all class properties can be set using the following sources, listed by priority (1 = highest):

4.  Defaults provided with the property definitions

The final values for the config instance's properties are calculated upon instantiation.

##### options.enforceReadonly: _`boolean`_

Enforce that all properties are read-only by using `Object.freeze()` (default: true)

##### options.loadEnvFromFile: _`false`_ | [DotenvConfigOptions](https://www.npmjs.com/package/dotenv/v/6.2.0#options)

Apply environment variables from a file to the current `process.env`

##### options.parseArgv: _`false`_ | `IArgvOptions`

Whether to parse command line arguments (default: true)

##### options.parseArgv.prefix: _`string`_

Prefix for command line arguments (default: no prefix)

##### options.parseEnv: `false` | `IEnvOptions`

Whether to parse environment variables (default: true)

##### options.parseEnv.lowerCase: _`boolean`_

Whether to lower-case environment variables (default: false)

##### options.parseEnv.prefix: _`string`_

Prefix for environment variables (default: no prefix)

##### options.parseEnv.separator: _`string`_

Seperator for environment variables (default: '\_\_')

		# CHANGELOG

		## 2.1.0
		- In case a property is an object create a new instance of that object instead of using a POJO (https://github.com/derbenoo/ts-configurable/issues/37)
		-

		## 2.0.1
		@@ -4,0 +8,0 @@ - Fix a bug where non-ciphertext string values where set to null with setNullOnDecryptionFailure=true

		@@ -39,3 +39,3 @@ "use strict";
		if (isObject(value)) {
		obj[key] = {};
		obj[key] = new templateValue.constructor();
		assignValuesByTemplate(obj[key], templateValue, value, options, decryption, `${parent}.${key}`);
		@@ -42,0 +42,0 @@ }

		{
		"name": "ts-configurable",
		"version": "2.0.1",
		"version": "2.1.0",
		"license": "MIT",
		@@ -5,0 +5,0 @@ "author": "Benjamin Assadsolimani (derbenoo)",

		@@ -22,3 +22,3 @@ # TS-Configurable

		Let's be real, configuration is not sexy. We all just want to set up our project's configuration as easily as possible and then move on to build whatever we _actually_ wanted to build. But what if I told you that you can meet all your configuration needs with a single line of code and then never have to worry about it again?
		Let's be real, configuration is no fun. We all just want to set up our project's configuration as easily as possible and then move on to build whatever we _actually_ wanted to build. But what if I told you that you can meet all your configuration needs with a single line of code and then never have to worry about it again?

		@@ -25,0 +25,0 @@ Simply create a class defining all configuration properties, tack on the `@Configurable()` decorator and off you go! Take advantage of type-safety, environment variable loading, command line argument parsing and much more right out-of-the-box.

Improved metrics