@kibibit/configit 2.3.0 → 2.6.0

package/src/config.service.spec.ts

@@ -2,22 +2,36 @@
 import fsExtra from 'fs-extra';
 import { mockProcessExit } from 'jest-mock-process';
 
-import { ConfigService } from './config.service';
-import { PizzaConfig, ToppingEnum } from './pizza.config.model.mock';
+import { ConfigService, EFileFormats, IConfigServiceOptions } from './config.service';
+import { PizzaConfig, ToppingEnum, ToppingsConfig } from './pizza.config.model.mock';
 
 class PizzaConfigService extends ConfigService<PizzaConfig> {
-  constructor(passedConfig?: Partial<PizzaConfig>) {
-    super(PizzaConfig, passedConfig);
+  constructor(passedConfig?: Partial<PizzaConfig>, options?: IConfigServiceOptions) {
+    super(PizzaConfig, passedConfig, options);
   }
 }
 
 describe('Config Service', () => {
   let configService: PizzaConfigService;
+  let mockExit;
   beforeAll(() => {
     configService = new PizzaConfigService({
       NODE_ENV: 'test'
     });
   });
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+    mockExit = mockProcessExit();
+
+    (fsExtra.writeJSONSync as jest.Mock).mockReturnValue(false);
+    (fsExtra.writeFileSync as jest.Mock).mockReturnValue(false);
+    (fsExtra.pathExistsSync as jest.Mock).mockReturnValue(true);
+  });
+
+  afterEach(() => {
+    mockExit.mockRestore();
+  });
   test('Service creation', () => {
     expect(configService).toBeDefined();
   });
@@ -38,10 +52,7 @@ describe('Config Service', () => {
   });
 
   test('Service can initialize the config files with saveToFile or init param', () => {
-    (fsExtra.writeJSONSync as jest.Mock).mockReturnValue(false);
     (fsExtra.pathExistsSync as jest.Mock).mockReturnValue(false);
-    const mockExit = mockProcessExit();
-    jest.clearAllMocks();
     new PizzaConfigService({
       saveToFile: true,
       NODE_ENV: 'test'
@@ -51,14 +62,9 @@ describe('Config Service', () => {
     expect((fsExtra.writeJSONSync as jest.Mock).mock.calls[0]).toMatchSnapshot();
     expect((fsExtra.writeJSONSync as jest.Mock).mock.calls[1]).toMatchSnapshot();
     expect(mockExit).toHaveBeenCalledWith(0);
-    mockExit.mockRestore();
   });
 
   test('Service can SAVE the config files with saveToFile or init param', () => {
-    (fsExtra.writeJSONSync as jest.Mock).mockReturnValue(false);
-    (fsExtra.pathExistsSync as jest.Mock).mockReturnValue(true);
-    jest.clearAllMocks();
-    const mockExit = mockProcessExit();
     new PizzaConfigService({
       saveToFile: true,
       NODE_ENV: 'test',
@@ -68,6 +74,234 @@ describe('Config Service', () => {
     expect(fsExtra.writeJSONSync).toHaveBeenCalledTimes(1);
     expect((fsExtra.writeJSONSync as jest.Mock).mock.calls[0]).toMatchSnapshot();
     expect(mockExit).toHaveBeenCalledWith(0);
-    mockExit.mockRestore();
+  });
+
+  test('Service can Save and CONVERT the config files with saveToFile or init param', () => {
+    new PizzaConfigService({
+      saveToFile: true,
+      convert: EFileFormats.yaml,
+      NODE_ENV: 'test',
+      toppings: [ ToppingEnum.Cheese ]
+    });
+
+    expect(fsExtra.writeFileSync).toHaveBeenCalledTimes(1);
+
+    const [ filePath, fileContent ] = (fsExtra.writeFileSync as jest.Mock).mock.calls[0];
+
+    expect(filePath).toMatchSnapshot();
+    expect(`\n${ fileContent }\n`).toMatchSnapshot();
+    expect(mockExit).toHaveBeenCalledWith(0);
+  });
+
+  describe('wrap variables in attribute', () => {
+    test('YAML', () => {
+      new PizzaConfigService({
+        saveToFile: true,
+        convert: EFileFormats.yaml,
+        wrapper: 'env_variables',
+        NODE_ENV: 'test',
+        toppings: [ ToppingEnum.Cheese ]
+      });
+
+      expect(fsExtra.writeFileSync).toHaveBeenCalledTimes(1);
+
+      const [ filePath, fileContent ] = (fsExtra.writeFileSync as jest.Mock).mock.calls[0];
+
+      expect(filePath).toMatchSnapshot();
+      expect(`\n${ fileContent }\n`).toMatchSnapshot();
+      expect(mockExit).toHaveBeenCalledWith(0);
+    });
+
+    test('JSONC', () => {
+      new PizzaConfigService({
+        saveToFile: true,
+        wrapper: 'env_variables',
+        NODE_ENV: 'test',
+        toppings: [ ToppingEnum.Cheese ]
+      }, { fileFormat: EFileFormats.jsonc });
+
+      expect(fsExtra.writeJSONSync).toHaveBeenCalledTimes(1);
+
+      const [ filePath, fileContent ] = (fsExtra.writeJSONSync as jest.Mock).mock.calls[0];
+
+      expect(filePath).toMatchSnapshot();
+      expect(fileContent).toMatchSnapshot();
+      expect(mockExit).toHaveBeenCalledWith(0);
+    });
+
+    test('JSON', () => {
+      new PizzaConfigService({
+        saveToFile: true,
+        wrapper: 'env_variables',
+        NODE_ENV: 'test',
+        toppings: [ ToppingEnum.Cheese ]
+      });
+
+      expect(fsExtra.writeJSONSync).toHaveBeenCalledTimes(1);
+
+      const [ filePath, fileContent ] = (fsExtra.writeJSONSync as jest.Mock).mock.calls[0];
+
+      expect(filePath).toMatchSnapshot();
+      expect(fileContent).toMatchSnapshot();
+      expect(mockExit).toHaveBeenCalledWith(0);
+    });
+  });
+
+  test('Service returns correct empty yaml when config is empty', () => {
+    new PizzaConfigService({
+      saveToFile: true,
+      convert: EFileFormats.yaml
+    });
+
+    expect(fsExtra.writeFileSync).toHaveBeenCalledTimes(1);
+
+    const [ filePath, fileContent ] = (fsExtra.writeFileSync as jest.Mock).mock.calls[0];
+
+    expect(filePath).toMatchSnapshot();
+    expect(fileContent.trim()).toMatchSnapshot();
+    expect(mockExit).toHaveBeenCalledWith(0);
+  });
+
+  test('Service can return a plain object', () => {
+    const pizzaConfigInstance = new PizzaConfigService({
+      NODE_ENV: 'test',
+      toppings: [ ToppingEnum.Cheese ]
+    });
+
+    const plainObjectConfig = pizzaConfigInstance.toPlainObject();
+    expect(plainObjectConfig).toMatchSnapshot();
+  });
+
+  test('Service can save yaml without schema', async () => {
+    const pizzaConfigInstance = new PizzaConfigService({
+      NODE_ENV: 'test',
+      toppings: [ ToppingEnum.Cheese ]
+    });
+
+    await pizzaConfigInstance.writeConfigToFile({
+      fileFormat: EFileFormats.yaml,
+      excludeSchema: true
+    });
+
+    expect(fsExtra.writeFileSync).toHaveBeenCalledTimes(1);
+
+    const [ filePath, fileContent ] = (fsExtra.writeFileSync as jest.Mock).mock.calls[0];
+
+    expect(filePath).toMatchSnapshot();
+    expect(fileContent).not.toContain('# yaml-language-server: $schema=');
+    expect(fileContent).toMatchSnapshot();
+  });
+
+  test('writeConfigToFile YAML', () => {
+    const config = new PizzaConfigService({
+      toppings: [ ToppingEnum.Cheese ]
+    });
+
+    config.writeConfigToFile({
+      fileFormat: EFileFormats.yaml,
+      excludeSchema: true,
+      objectWrapper: 'env_variables'
+    });
+
+    expect(fsExtra.writeFileSync).toHaveBeenCalledTimes(1);
+
+    const [ filePath, fileContent ] = (fsExtra.writeFileSync as jest.Mock).mock.calls[0];
+
+    expect(filePath).toMatchSnapshot();
+    expect(fileContent.trim()).toMatchSnapshot();
+  });
+
+  test('writeConfigToFile HJSON', () => {
+    const config = new PizzaConfigService({
+      toppings: [ ToppingEnum.Cheese ]
+    });
+
+    config.writeConfigToFile({
+      fileFormat: EFileFormats.hjson,
+      excludeSchema: true,
+      objectWrapper: 'env_variables'
+    });
+
+    expect(fsExtra.writeFileSync).toHaveBeenCalledTimes(1);
+
+    const [ filePath, fileContent ] = (fsExtra.writeFileSync as jest.Mock).mock.calls[0];
+
+    expect(filePath).toMatchSnapshot();
+    expect(fileContent.trim()).toMatchSnapshot();
+  });
+
+  test('writeConfigToFile JSONC', () => {
+    const config = new PizzaConfigService({
+      toppings: [ ToppingEnum.Cheese ]
+    });
+
+    jest.clearAllMocks();
+
+    config.writeConfigToFile({
+      fileFormat: EFileFormats.jsonc,
+      excludeSchema: true,
+      objectWrapper: 'env_variables'
+    });
+
+    expect(fsExtra.writeJSONSync).toHaveBeenCalledTimes(1);
+
+    const [ filePath, fileContent ] = (fsExtra.writeJSONSync as jest.Mock).mock.calls[0];
+
+    expect(filePath).toMatchSnapshot();
+    expect(fileContent).toMatchSnapshot();
+  });
+
+  test('writeConfigToFile JSON', () => {
+    const config = new PizzaConfigService({
+      toppings: [ ToppingEnum.Cheese ]
+    });
+
+    jest.clearAllMocks();
+
+    config.writeConfigToFile({
+      fileFormat: EFileFormats.json,
+      excludeSchema: true,
+      objectWrapper: 'env_variables'
+    });
+
+    expect(fsExtra.writeJSONSync).toHaveBeenCalledTimes(1);
+
+    const [ filePath, fileContent ] = (fsExtra.writeJSONSync as jest.Mock).mock.calls[0];
+
+    expect(filePath).toMatchSnapshot();
+    expect(fileContent).toMatchSnapshot();
+  });
+
+  describe('Shared Configurations', () => {
+    test('Can define shared config', () => {
+      const pizzaConfigInstance = new PizzaConfigService({
+        NODE_ENV: 'test',
+        toppings: [ ToppingEnum.Cheese ],
+        INCLUDE_MEAT: true
+      } as any, {
+        sharedConfig: [ ToppingsConfig ]
+      });
+
+      pizzaConfigInstance.writeConfigToFile({
+        fileFormat: EFileFormats.json
+        // excludeSchema: false
+      });
+
+      expect(fsExtra.writeJSONSync).toHaveBeenCalledTimes(4);
+
+      const [ filePath0, fileContent0 ] = (fsExtra.writeJSONSync as jest.Mock).mock.calls[0];
+      const [ filePath1, fileContent1 ] = (fsExtra.writeJSONSync as jest.Mock).mock.calls[1];
+      const [ filePath2, fileContent2 ] = (fsExtra.writeJSONSync as jest.Mock).mock.calls[2];
+      const [ filePath3, fileContent3 ] = (fsExtra.writeJSONSync as jest.Mock).mock.calls[3];
+
+      expect(filePath0).toMatchSnapshot();
+      expect(fileContent0).toMatchSnapshot();
+      expect(filePath1).toMatchSnapshot();
+      expect(fileContent1).toMatchSnapshot();
+      expect(filePath2).toMatchSnapshot();
+      expect(fileContent2).toMatchSnapshot();
+      expect(filePath3).toMatchSnapshot();
+      expect(fileContent3).toMatchSnapshot();
+    });
   });
 });

package/src/config.service.ts

@@ -11,23 +11,32 @@ import {
   readJSONSync,
   writeFileSync,
   writeJSONSync } from 'fs-extra';
+import { stringify as hjsonStringify } from 'hjson';
 import { camelCase, chain, keys, mapValues, startCase, times } from 'lodash';
-import nconf, { IFormats } from 'nconf';
+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 { BaseConfig } from './config.model';
 import { getEnvironment, setEnvironment } from './environment.service';
 
-type IYamlIncludedFormats = IFormats & { yaml: nconfYamlFormat };
+type INconfKibibitFormats = IFormats & {
+  yaml: nconfYamlFormat;
+  jsonc: IFormat;
+};
 
-const nconfFomrats = (nconf.formats as IYamlIncludedFormats).yaml = nconfYamlFormat;
+const nconfFormats = nconf.formats as INconfKibibitFormats;
+nconfFormats.yaml = nconfYamlFormat;
+nconfFormats.jsonc = nconfJsoncFormat;
 
 export interface IConfigServiceOptions {
   convertToCamelCase?: boolean;
-  useYaml?: boolean;
+  fileFormat?: EFileFormats;
   sharedConfig?: TClass<BaseConfig>[];
+  skipSchema?: boolean;
   schemaFolderName?: string;
   showOverrides?: boolean;
   configFolderRelativePath?: string;
@@ -37,8 +46,15 @@ export interface IConfigServiceOptions {
   };
 }
 
+export enum EFileFormats {
+  json = 'json',
+  yaml = 'yaml',
+  jsonc = 'jsonc',
+  hjson = 'hjson'
+}
+
 export interface IWriteConfigToFileOptions {
-    useYaml: boolean;
+    fileFormat: EFileFormats;
     excludeSchema?: boolean;
     objectWrapper?: string;
     outputFolder?: string;
@@ -56,7 +72,7 @@ type TClass<T> = (new (partial: Partial<T>) => T);
  * first one.
  */
 export class ConfigService<T extends BaseConfig> {
-  private fileExtension: 'yaml' | 'json';
+  private fileExtension: EFileFormats;
   readonly mode: string = getEnvironment();
   readonly options: IConfigServiceOptions;
   readonly config?: T;
@@ -79,15 +95,16 @@ export class ConfigService<T extends BaseConfig> {
 
     this.options = {
       sharedConfig: [],
-      useYaml: false,
+      fileFormat: EFileFormats.json,
       convertToCamelCase: false,
       schemaFolderName: '.schemas',
+      skipSchema: false,
       showOverrides: false,
       ...options
     };
     this.appRoot = this.findRoot();
     this.genericClass = givenClass;
-    this.fileExtension = this.options.useYaml ? 'yaml' : '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();
@@ -120,15 +137,17 @@ export class ConfigService<T extends BaseConfig> {
       if (config.convert) {
         console.log(cyan('Converting Configuration File'));
       }
-      const useYaml = config.convert ? !this.options.useYaml : this.options.useYaml;
+      const fileFormat = config.convert ? config.convert : this.fileExtension;
       const objectWrapper = config.wrapper;
-      this.writeConfigToFile({ useYaml, objectWrapper, excludeSchema: config.convert });
+      this.writeConfigToFile({ fileFormat, objectWrapper });
       console.log(cyan('EXITING'));
       process.exit(0);
       return;
     }
 
-    this.writeSchema();
+    if (!this.options.skipSchema) {
+      this.writeSchema();
+    }
 
     configService = this;
   }
@@ -140,15 +159,15 @@ export class ConfigService<T extends BaseConfig> {
 
   writeConfigToFile(
     {
-      useYaml,
+      fileFormat,
       excludeSchema,
       objectWrapper,
       outputFolder
     }: IWriteConfigToFileOptions = {
-      useYaml: this.options.useYaml,
+      fileFormat: this.options.fileFormat,
       excludeSchema: false
     }) {
-    const fileExtension = useYaml ? 'yaml' : 'json';
+    const fileExtension = fileFormat;
     const configFileName = this.config.getFileName(fileExtension);
     const configFileFullPath = join(
       outputFolder || this.configFileRoot,
@@ -164,7 +183,7 @@ export class ConfigService<T extends BaseConfig> {
     }
     const orderedKeys = this.orderObjectKeys(plainConfig);
 
-    if (useYaml) {
+    if (fileFormat === 'yaml') {
       const yamlValues = chain(orderedKeys)
         .omit([ '$schema' ])
         // eslint-disable-next-line no-undefined
@@ -193,7 +212,16 @@ export class ConfigService<T extends BaseConfig> {
       { [objectWrapper]: orderedKeys } :
       orderedKeys;
 
-    writeJSONSync(this.configFileFullPath, output, { spaces: 2 });
+    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);
@@ -221,7 +249,7 @@ export class ConfigService<T extends BaseConfig> {
       });
 
     const nconfFileOptions: nconf.IFileOptions = {
-      format: this.options.useYaml ? nconfFomrats : null
+      format: nconfFormats[this.options.fileFormat]
     };
 
     if (this.options.encryptConfig) {
@@ -340,7 +368,7 @@ export class ConfigService<T extends BaseConfig> {
 
     const orderedKeys = this.orderObjectKeys(plainConfig);
 
-    if (this.options.useYaml) {
+    if (this.options.fileFormat === 'yaml') {
       const yamlValues = chain(orderedKeys)
         .omit([ '$schema' ])
       // eslint-disable-next-line no-undefined

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

@@ -1,4 +1,4 @@
-import { IsEnum, IsOptional } from 'class-validator';
+import { IsBoolean, IsEnum, IsOptional } from 'class-validator';
 import { values } from 'lodash';
 
 import { BaseConfig, Configuration, ConfigVariable } from './';
@@ -24,5 +24,10 @@ export class PizzaConfig extends BaseConfig {
   }
 }
 
-global.ToppingEnum = ToppingEnum;
-global.PizzaConfig = PizzaConfig;
+@Configuration()
+export class ToppingsConfig extends BaseConfig {
+  @IsOptional()
+  @IsBoolean()
+  @ConfigVariable('Should meat be included in the toppings options')
+  INCLUDE_MEAT;
+}