@kibibit/configit 2.2.1 → 2.5.1

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,215 @@ 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 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

@@ -12,21 +12,28 @@ import {
   writeFileSync,
   writeJSONSync } from 'fs-extra';
 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>[];
   schemaFolderName?: string;
   showOverrides?: boolean;
@@ -37,6 +44,19 @@ export interface IConfigServiceOptions {
   };
 }
 
+export enum EFileFormats {
+  json = 'json',
+  yaml = 'yaml',
+  jsonc = 'jsonc',
+}
+
+export interface IWriteConfigToFileOptions {
+    fileFormat: EFileFormats;
+    excludeSchema?: boolean;
+    objectWrapper?: string;
+    outputFolder?: string;
+}
+
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 let configService: ConfigService<any>;
 
@@ -49,7 +69,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;
@@ -72,7 +92,7 @@ export class ConfigService<T extends BaseConfig> {
 
     this.options = {
       sharedConfig: [],
-      useYaml: false,
+      fileFormat: EFileFormats.json,
       convertToCamelCase: false,
       schemaFolderName: '.schemas',
       showOverrides: false,
@@ -80,7 +100,7 @@ export class ConfigService<T extends BaseConfig> {
     };
     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();
@@ -113,9 +133,9 @@ 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, config.convert);
+      this.writeConfigToFile({ fileFormat, objectWrapper });
       console.log(cyan('EXITING'));
       process.exit(0);
       return;
@@ -131,16 +151,25 @@ export class ConfigService<T extends BaseConfig> {
     return classToPlain(new this.genericClass(this.config));
   }
 
-  writeConfigToFile(useYaml = this.options.useYaml, objectWrapper?: string, excludeSchema = false) {
-    const fileExtension = useYaml ? 'yaml' : 'json';
+  writeConfigToFile(
+    {
+      fileFormat,
+      excludeSchema,
+      objectWrapper,
+      outputFolder
+    }: IWriteConfigToFileOptions = {
+      fileFormat: this.options.fileFormat,
+      excludeSchema: false
+    }) {
+    const fileExtension = fileFormat;
     const configFileName = this.config.getFileName(fileExtension);
     const configFileFullPath = join(
-      this.configFileRoot,
+      outputFolder || this.configFileRoot,
       configFileName
     );
     const plainConfig = classToPlain(this.config);
     const relativePathToSchema = relative(
-      this.configFileRoot,
+      outputFolder || this.configFileRoot,
       join(this.appRoot, `/${ this.options.schemaFolderName }/${ this.config.getSchemaFileName() }`)
     );
     if (!excludeSchema) {
@@ -148,7 +177,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
@@ -177,7 +206,7 @@ export class ConfigService<T extends BaseConfig> {
       { [objectWrapper]: orderedKeys } :
       orderedKeys;
 
-    writeJSONSync(this.configFileFullPath, output, { spaces: 2 });
+    writeJSONSync(configFileFullPath, output, { spaces: 2 });
 
     for (const sharedConfig of this.options.sharedConfig) {
       this.writeSharedConfigToFile(sharedConfig);
@@ -205,7 +234,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) {
@@ -324,7 +353,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;
+}