@kibibit/configit 1.0.0-beta.1 → 1.0.0-beta.16

package/src/config.service.ts

@@ -1,31 +1,68 @@
-import { join } from 'path';
+import { join, relative } from 'path';
 
 import { classToPlain } from 'class-transformer';
 import { validateSync } from 'class-validator';
+import { cyan, red } from 'colors';
 import findRoot from 'find-root';
 import {
+  ensureDirSync,
   pathExistsSync,
   readdirSync,
   readJSONSync,
-  writeJson,
-  writeJSONSync
-} from 'fs-extra';
-import { camelCase, chain, get } from 'lodash';
-import nconf from 'nconf';
+  writeFileSync,
+  writeJSONSync } from 'fs-extra';
+import { stringify as hjsonStringify } from 'hjson';
+import { camelCase, chain, keys, mapValues, startCase, times } from 'lodash';
+import nconf, { IFormat, IFormats } from 'nconf';
+import nconfYamlFormat from 'nconf-yaml';
+import YAML from 'yaml';
+
+import * as nconfJsoncFormat from '@kibibit/nconf-jsonc';
 
 import { ConfigValidationError } from './config.errors';
-import { Config } from './config.model';
+import { BaseConfig } from './config.model';
+import { getEnvironment, setEnvironment } from './environment.service';
+
+type INconfKibibitFormats = IFormats & {
+  yaml: nconfYamlFormat;
+  jsonc: IFormat;
+};
+
+const nconfFormats = nconf.formats as INconfKibibitFormats;
+nconfFormats.yaml = nconfYamlFormat;
+nconfFormats.jsonc = nconfJsoncFormat;
 
 export interface IConfigServiceOptions {
   convertToCamelCase?: boolean;
+  fileFormat?: EFileFormats;
+  sharedConfig?: TClass<BaseConfig>[];
+  schemaFolderName?: string;
+  showOverrides?: boolean;
+  configFolderRelativePath?: string;
+  encryptConfig?: {
+    algorithm: string;
+    secret: string;
+  };
 }
 
-const environment = get(process, 'env.NODE_ENV', 'development');
+export enum EFileFormats {
+  json = 'json',
+  yaml = 'yaml',
+  jsonc = 'jsonc',
+  hjson = 'hjson'
+}
+
+export interface IWriteConfigToFileOptions {
+    fileFormat: EFileFormats;
+    excludeSchema?: boolean;
+    objectWrapper?: string;
+    outputFolder?: string;
+}
 
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 let configService: ConfigService<any>;
 
-type TClass<T> = new (partial: Partial<T>) => T;
+type TClass<T> = (new (partial: Partial<T>) => T);
 
 /**
  * This is a **Forced Singleton**.
@@ -33,16 +70,15 @@ type TClass<T> = new (partial: Partial<T>) => T;
  * another ConfigService, you'll always get the
  * first one.
  */
-export class ConfigService<T extends Config> {
-  private readonly mode: string = environment;
+export class ConfigService<T extends BaseConfig> {
+  private fileExtension: EFileFormats;
+  readonly mode: string = getEnvironment();
   readonly options: IConfigServiceOptions;
   readonly config?: T;
   readonly genericClass?: TClass<T>;
   readonly fileName?: string;
-  readonly jsonSchemaFullname?: string;
-  readonly defaultConfigFilePath?: string;
   readonly configFileName: string = '';
-  readonly configFilePath?: string;
+  readonly configFileFullPath?: string;
   readonly configFileRoot?: string;
   readonly appRoot: string;
 
@@ -51,77 +87,302 @@ export class ConfigService<T extends Config> {
     passedConfig?: Partial<T>,
     options: IConfigServiceOptions = {}
   ) {
-    this.options = options;
-    this.appRoot = this.findRoot();
     if (!passedConfig && configService) { return configService; }
 
+    setEnvironment(passedConfig?.NODE_ENV || getEnvironment());
+    this.mode = getEnvironment();
+
+    this.options = {
+      sharedConfig: [],
+      fileFormat: EFileFormats.json,
+      convertToCamelCase: false,
+      schemaFolderName: '.schemas',
+      showOverrides: false,
+      ...options
+    };
+    this.appRoot = this.findRoot();
     this.genericClass = givenClass;
-    this.fileName = chain(this.genericClass.name)
-      .replace(/Config$/i, '')
-      .kebabCase()
-      .value();
-    this.jsonSchemaFullname = `.${ this.fileName }.env.schema.json`;
+    this.fileExtension = this.options.fileFormat || EFileFormats.json;
+    this.config = this.createConfigInstance(this.genericClass, {}) as T;
+    this.configFileName = this.config.getFileName(this.fileExtension);
+    this.configFileRoot = this.findConfigRoot();
+    this.configFileFullPath = join(
+      this.configFileRoot,
+      this.configFileName
+    );
+
+    this.initializeNconf();
 
-    this.configFileName = `${ this.fileName }.${ environment }.env.json`;
+    const config = passedConfig || nconf.get();
 
-    this.configFileRoot = this.findConfigRoot() || this.appRoot;
+    const pathDoesNotExist = pathExistsSync(this.configFileFullPath) === false;
+    if (pathDoesNotExist && (config.saveToFile || config.init)) {
+      console.log(cyan('Initializing Configuration File'));
+      this.config = this.createConfigInstance(this.genericClass, {}) as T;
+      this.writeConfigToFile();
+      this.writeSchema();
+      console.log(cyan('EXITING'));
+      process.exit(0);
+      return;
+    }
 
-    this.defaultConfigFilePath = join(this.configFileRoot, 'defaults.env.json');
-    this.configFilePath = join(
-      this.configFileRoot,
-      `${ this.fileName }.${ environment }.env.json`
+    const envConfig = this.validateInput(config);
+    if (!envConfig) { return; }
+    envConfig.NODE_ENV = this.mode;
+    this.config = this.createConfigInstance(this.genericClass, envConfig as T) as T;
+
+    if (config.saveToFile || config.init) {
+      if (config.convert) {
+        console.log(cyan('Converting Configuration File'));
+      }
+      const fileFormat = config.convert ? config.convert : this.fileExtension;
+      const objectWrapper = config.wrapper;
+      this.writeConfigToFile({ fileFormat, objectWrapper });
+      console.log(cyan('EXITING'));
+      process.exit(0);
+      return;
+    }
+
+    this.writeSchema();
+
+    configService = this;
+  }
+
+  toPlainObject() {
+    // hope this works now!
+    return classToPlain(new this.genericClass(this.config));
+  }
+
+  writeConfigToFile(
+    {
+      fileFormat,
+      excludeSchema,
+      objectWrapper,
+      outputFolder
+    }: IWriteConfigToFileOptions = {
+      fileFormat: this.options.fileFormat,
+      excludeSchema: false
+    }) {
+    const fileExtension = fileFormat;
+    const configFileName = this.config.getFileName(fileExtension);
+    const configFileFullPath = join(
+      outputFolder || this.configFileRoot,
+      configFileName
+    );
+    const plainConfig = classToPlain(this.config);
+    const relativePathToSchema = relative(
+      outputFolder || this.configFileRoot,
+      join(this.appRoot, `/${ this.options.schemaFolderName }/${ this.config.getSchemaFileName() }`)
     );
+    if (!excludeSchema) {
+      plainConfig.$schema = relativePathToSchema;
+    }
+    const orderedKeys = this.orderObjectKeys(plainConfig);
+
+    if (fileFormat === 'yaml') {
+      const yamlValues = chain(orderedKeys)
+        .omit([ '$schema' ])
+        // eslint-disable-next-line no-undefined
+        .omitBy((value) => value === undefined)
+        .value();
+
+      const output = objectWrapper ?
+        { [objectWrapper]: yamlValues } :
+        yamlValues;
+      const yamlString = keys(yamlValues).length > 0 ? YAML.stringify(output) : '';
+      writeFileSync(
+        configFileFullPath,
+        [
+          excludeSchema ? '' : [
+            '# yaml-language-server: $schema=',
+            relativePathToSchema,
+            '\n'
+          ].join(''),
+          yamlString
+        ].join('')
+      );
+      return;
+    }
+
+    const output = objectWrapper ?
+      { [objectWrapper]: orderedKeys } :
+      orderedKeys;
+
+    if (fileFormat === 'hjson') {
+      writeFileSync(configFileFullPath, hjsonStringify(output, {
+        quotes: 'min',
+        space: 2
+      }));
+
+      return;
+    }
 
+    writeJSONSync(configFileFullPath, output, { spaces: 2 });
+
+    for (const sharedConfig of this.options.sharedConfig) {
+      this.writeSharedConfigToFile(sharedConfig);
+    }
+  }
+
+  private createConfigInstance(genericClass: TClass<BaseConfig>, data) {
+    const configInstance = new genericClass(data);
+    configInstance.setName(genericClass);
+
+    return configInstance;
+  }
+
+  private initializeNconf() {
     nconf
       .argv({
         parseValues: true
       })
       .env({
+        separator: '__',
         parseValues: true,
         transform: this.options.convertToCamelCase ?
           transformToCamelCase :
           null
-      })
-      .file('defaults', { file: this.defaultConfigFilePath })
-      .file('environment', { file: this.configFilePath });
+      });
 
-    const config = passedConfig || nconf.get();
-    const envConfig = this.validateInput(config);
+    const nconfFileOptions: nconf.IFileOptions = {
+      format: nconfFormats[this.options.fileFormat]
+    };
 
-    this.config = new this.genericClass(envConfig as T);
+    if (this.options.encryptConfig) {
+      nconfFileOptions.secure = {
+        secret: this.options.encryptConfig.secret,
+        alg: this.options.encryptConfig.algorithm
+      };
+    }
 
-    if (config.saveToFile || config.init) {
-      const plainConfig = classToPlain(this.config);
-      plainConfig.$schema = `./${ this.jsonSchemaFullname }`;
-      const orderedKeys = chain(plainConfig)
-        .keys()
-        .sort()
-        .without('NODE_ENV')
-        .reduce((obj: { [key: string]: string }, key) => {
-          obj[key] = plainConfig[key];
-          return obj;
-        }, {})
-        // .omitBy((value, key) => key.startsWith('$'))
-        .value();
+    try {
+      nconf
+        .file('environment', {
+          file: this.configFileFullPath,
+          ...nconfFileOptions
+        });
+    } catch (error) {
+      console.error(red(error.message));
+      process.exit(1);
+    }
 
-      console.log(orderedKeys);
+    for (const sharedConfig of this.options.sharedConfig) {
+      const sharedConfigInstance = this.createConfigInstance(sharedConfig, {});
+      const sharedConfigFullPath = join(
+        this.configFileRoot,
+        sharedConfigInstance.getFileName(this.fileExtension, true),
+      );
+      try {
+        nconf.file(sharedConfigInstance.name, {
+          file: sharedConfigFullPath,
+          ...nconfFileOptions
+        });
+      } catch (error) {
+        console.error(red(error.message));
+        process.exit(1);
+      }
+    }
+  }
 
-      writeJson(this.configFilePath, orderedKeys, { spaces: 2 });
+  private writeSchema() {
+    ensureDirSync(join(this.configFileRoot, '/', this.options.schemaFolderName));
+    const sharedConfigsSchemas = [];
+    for (const sharedConfig of this.options.sharedConfig) {
+      const sharedConfigSchema = this.writeSharedSchema(sharedConfig);
+      sharedConfigsSchemas.push(sharedConfigSchema);
     }
 
     const schema = this.config.toJsonSchema();
     const schemaFullPath = join(
       this.configFileRoot,
       '/',
-      this.jsonSchemaFullname
+      this.options.schemaFolderName,
+      '/',
+      this.config.getSchemaFileName()
     );
-    writeJSONSync(schemaFullPath, schema);
 
-    configService = this;
+    let sharedConfigsProperties = {};
+    for (const sharedConfigSchema of sharedConfigsSchemas) {
+      mapValues(
+        sharedConfigSchema.properties,
+        (value) => value.description = `(OVERRIDE SHARED CONFIG)\n${ value.description }`
+      );
+      sharedConfigsProperties = {
+        ...sharedConfigsProperties,
+        ...sharedConfigSchema.properties
+      };
+    }
+
+    if (this.options.showOverrides) {
+      schema.properties = {
+        ...this.orderObjectKeys(schema.properties),
+        ...this.orderObjectKeys(sharedConfigsProperties)
+      };
+    }
+
+    writeJSONSync(schemaFullPath, schema, { spaces: 2 });
   }
 
-  toPlainObject() {
-    return classToPlain(this);
+  private orderObjectKeys(given: { [key: string]: any }) {
+    return chain(given)
+      .keys()
+      .sort()
+      .reduce((obj: { [key: string]: any }, key) => {
+        obj[key] = given[key];
+        return obj;
+      }, {})
+      .value();
+  }
+
+  private writeSharedSchema(configClass: TClass<BaseConfig>) {
+    const config = this.createConfigInstance(configClass, {});
+    const schema = config.toJsonSchema();
+    const schemaFullPath = join(
+      this.configFileRoot,
+      '/',
+      this.options.schemaFolderName,
+      '/',
+      config.getSchemaFileName()
+    );
+    writeJSONSync(schemaFullPath, schema, { spaces: 2 });
+
+    return schema;
+  }
+
+  private writeSharedConfigToFile(configClass: TClass<BaseConfig>) {
+    const config = this.createConfigInstance(configClass, this.config);
+    const plainConfig = classToPlain(config);
+    const relativePathToSchema = relative(
+      this.configFileRoot,
+      join(this.appRoot, `/${ this.options.schemaFolderName }/${ config.getSchemaFileName() }`)
+    );
+    plainConfig.$schema = relativePathToSchema;
+    const sharedConfigFullPath = join(
+      this.configFileRoot,
+      config.getFileName(this.fileExtension, true)
+    );
+
+    const orderedKeys = this.orderObjectKeys(plainConfig);
+
+    if (this.options.fileFormat === 'yaml') {
+      const yamlValues = chain(orderedKeys)
+        .omit([ '$schema' ])
+      // eslint-disable-next-line no-undefined
+        .omitBy((value) => value === undefined)
+        .value();
+      const yamlString = keys(yamlValues).length > 0 ? YAML.stringify(yamlValues) : '';
+      writeFileSync(
+        sharedConfigFullPath,
+        [
+          '# yaml-language-server: $schema=',
+          relativePathToSchema,
+          `\n${ yamlString }`
+        ].join('')
+      );
+      return;
+    }
+
+    writeJSONSync(sharedConfigFullPath, orderedKeys, { spaces: 2 });
   }
 
   private findRoot() {
@@ -141,6 +402,12 @@ export class ConfigService<T extends Config> {
   }
 
   private findConfigRoot() {
+    if (this.options.configFolderRelativePath) {
+      const fullPath = join(this.appRoot, this.options.configFolderRelativePath);
+      ensureDirSync(fullPath);
+
+      return fullPath;
+    }
     try {
       return findRoot(process.cwd(), (dir) => {
         const fileNames = readdirSync(dir);
@@ -163,10 +430,65 @@ export class ConfigService<T extends Config> {
     const configInstance = new this.genericClass(envConfig);
     const validationErrors = validateSync(configInstance);
 
+    let fullConfig = {};
+    let shouldExitProcess = false;
+    for (const sharedConfig of this.options.sharedConfig) {
+      const validationResult = this.validateSharedInput(envConfig, sharedConfig);
+      shouldExitProcess = shouldExitProcess || validationResult.error;
+      fullConfig = {
+        ...fullConfig,
+        ...validationResult.configInstance
+      };
+    }
+
     if (validationErrors.length > 0) {
-      throw new ConfigValidationError(validationErrors);
+      const validationError = new ConfigValidationError(validationErrors);
+      const errorMessageTitle = `${ startCase(this.config.name) } Configuration Errors`;
+      const titleBar = this.generateTerminalTitleBar(errorMessageTitle);
+      console.error(titleBar, validationError.message);
+
+      shouldExitProcess = shouldExitProcess || validationErrors.length > 0;
     }
-    return classToPlain(configInstance) as Partial<T>;
+
+    if (shouldExitProcess) {
+      process.exit(1);
+      return;
+    }
+
+    return {
+      ...fullConfig,
+      ...classToPlain(configInstance) as Partial<T>
+    };
+  }
+
+  private validateSharedInput(
+    envConfig: unknown,
+    configClass: TClass<BaseConfig>
+  ) {
+    const configInstance = this.createConfigInstance(configClass, envConfig);
+    const validationErrors = validateSync(configInstance);
+
+    let error = null;
+    if (validationErrors.length > 0) {
+      const validationError = new ConfigValidationError(validationErrors);
+      const errorMessageTitle = `${ startCase(configInstance.name) } Shared Configuration Errors`;
+      const titleBar = this.generateTerminalTitleBar(errorMessageTitle);
+      error = { titleBar, message: validationError.message };
+      console.error(titleBar, validationError.message);
+    }
+    return {
+      configInstance: classToPlain(configInstance),
+      error
+    };
+  }
+
+  private generateTerminalTitleBar(title: string) {
+    const titleBar = red(times(title.length + 4, () => '=').join(''));
+    return [
+      titleBar,
+      red('= ') + title + red(' ='),
+      titleBar
+    ].join('\n');
   }
 }
 

package/src/environment.service.ts

@@ -0,0 +1,13 @@
+import { get } from 'lodash';
+
+const realEnvironment = get(process, 'env.NODE_ENV', 'development');
+
+let environment: string;
+
+export function setEnvironment(givenEnvironment: string) {
+  environment = givenEnvironment;
+}
+
+export function getEnvironment() {
+  return environment || realEnvironment;
+}

package/src/index.ts

@@ -2,3 +2,4 @@ export * from './config.service';
 export * from './config.errors';
 export * from './config.model';
 export * from './json-schema.validator';
+export * from './environment.service';

package/src/json-schema.validator.ts

@@ -1,10 +1,16 @@
+import { Exclude, Expose } from 'class-transformer';
 import {
+  Validate,
   ValidatorConstraint,
   ValidatorConstraintInterface
 } from 'class-validator';
 
+export interface IConfigVariableOptions {
+  exclude?: boolean;
+}
+
 @ValidatorConstraint({ name: 'JsonSchema', async: false })
-export class JsonSchema implements ValidatorConstraintInterface {
+class JsonSchema implements ValidatorConstraintInterface {
   validate() {
     return true;
   }
@@ -13,3 +19,25 @@ export class JsonSchema implements ValidatorConstraintInterface {
     return '';
   }
 }
+
+export function Configuration(): ClassDecorator {
+  const exposeFn = Exclude();
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  return function(target: any) {
+    exposeFn(target);
+  };
+}
+
+export function ConfigVariable(
+  description: string | string[] = '',
+  options: IConfigVariableOptions = {}
+): PropertyDecorator {
+  description = Array.isArray(description) ? description : [ description ];
+  const exposeFn = options.exclude ? Exclude() : Expose();
+  const typeFn = Validate(JsonSchema, description);
+
+  return function(target: unknown, key: string) {
+    typeFn(target, key);
+    exposeFn(target, key);
+  };
+}

package/src/pizza.config.model.mock.ts

@@ -0,0 +1,33 @@
+import { IsBoolean, IsEnum, IsOptional } from 'class-validator';
+import { values } from 'lodash';
+
+import { BaseConfig, Configuration, ConfigVariable } from './';
+
+export enum ToppingEnum {
+  Cheese = 'cheese',
+  Pepperoni = 'pepperoni',
+  Sausage = 'sausage'
+}
+
+@Configuration()
+export class PizzaConfig extends BaseConfig {
+  @IsOptional()
+  @IsEnum(values(ToppingEnum), {
+    each: true,
+    message: `Topping must be one of: ${ values(ToppingEnum).join(', ') }`
+  })
+  @ConfigVariable('optional toppings for the pizza')
+  public toppings: ToppingEnum[];
+
+  constructor(partial?: Partial<PizzaConfig>) {
+    super(partial);
+  }
+}
+
+@Configuration()
+export class ToppingsConfig extends BaseConfig {
+  @IsOptional()
+  @IsBoolean()
+  @ConfigVariable('Should meat be included in the toppings options')
+  INCLUDE_MEAT;
+}