@rosen-bridge/config 0.1.0

package/.eslintignore

@@ -0,0 +1 @@
+dist

package/CHANGELOG.md

@@ -0,0 +1,8 @@
+# @rosen-bridge/config
+
+## 0.1.0
+
+### Minor Changes
+
+- added validateAndWriteConfig method to the ConfigValidator class to validate and update node-config files.
+- implemented major functionalities for config package

package/README.md

@@ -0,0 +1,24 @@
+# @rosen-bridge/config
+
+## Table of contents
+
+- [Introduction](#introduction)
+- [Installation](#installation)
+
+## Introduction
+
+a package to manage configs of rosen bridge projects
+
+## Installation
+
+npm:
+
+```sh
+npm i @rosen-bridge/config
+```
+
+yarn:
+
+```sh
+yarn add @rosen-bridge/config
+```

package/dist/cli.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env -S node --experimental-specifier-resolution=node
+export {};
+//# sourceMappingURL=cli.d.ts.map

package/dist/cli.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cli.d.ts","sourceRoot":"","sources":["../lib/cli.ts"],"names":[],"mappings":""}

package/dist/cli.js

@@ -0,0 +1,102 @@
+#!/usr/bin/env -S node --experimental-specifier-resolution=node
+import yargs from 'yargs';
+import { hideBin } from 'yargs/helpers';
+import chalk from 'chalk';
+import ora from 'ora';
+import { ConfigValidator } from './index';
+import * as fs from 'fs';
+import JsonBigIntFactory from 'json-bigint';
+import * as yaml from 'js-yaml';
+const JsonBigInt = JsonBigIntFactory({
+  alwaysParseAsBig: false,
+  useNativeBigInt: true,
+});
+yargs(hideBin(process.argv))
+  .command(
+    'generate-default',
+    'generates an object using the default values of the passed schema',
+    (yargs) =>
+      yargs
+        .option('schema', {
+          alias: 's',
+          demandOption: true,
+          description: 'input schema file path which should be in json format',
+          type: 'string',
+        })
+        .option('output', {
+          alias: 'o',
+          demandOption: true,
+          description: 'generated default values output path',
+          type: 'string',
+        })
+        .option('format', {
+          alias: 'f',
+          demandOption: true,
+          description: 'generated default values output path',
+          choices: ['json', 'yaml'],
+          default: 'yaml',
+          type: 'string',
+        }),
+    async (argv) => {
+      const spinner = ora();
+      spinner.start(`Generating config default values`);
+      const rawSchemaData = fs.readFileSync(argv.schema, 'utf-8');
+      const schema = JsonBigInt.parse(rawSchemaData);
+      const confValidator = new ConfigValidator(schema);
+      const defaultConf = confValidator.generateDefault();
+      let output = '';
+      switch (argv.format) {
+        case 'json': {
+          output = JsonBigInt.stringify(defaultConf);
+          break;
+        }
+        case 'yaml': {
+          output = yaml.dump(defaultConf);
+          break;
+        }
+      }
+      fs.writeFileSync(argv.output, output);
+      spinner.succeed(
+        chalk.green(`default config values were output at "${argv.output}"`)
+      );
+    }
+  )
+  .command(
+    'generate-ts-types',
+    'generates compatible TypeScript interface types for the passed schema',
+    (yargs) =>
+      yargs
+        .option('schema', {
+          alias: 's',
+          demandOption: true,
+          description: 'input schema file path which should be in json format',
+          type: 'string',
+        })
+        .option('output', {
+          alias: 'o',
+          demandOption: true,
+          description: 'generated TypeScript interfaces',
+          type: 'string',
+        })
+        .option('root-type', {
+          alias: 'r',
+          demandOption: true,
+          description: 'Name of top root interface',
+          type: 'string',
+        }),
+    async (argv) => {
+      const spinner = ora();
+      spinner.start(`Generating TypeScript types`);
+      const rawSchemaData = fs.readFileSync(argv.schema, 'utf-8');
+      const schema = JsonBigInt.parse(rawSchemaData);
+      const confValidator = new ConfigValidator(schema);
+      const tsTypes = confValidator.generateTSTypes(argv.rootType);
+      fs.writeFileSync(argv.output, tsTypes);
+      spinner.succeed(
+        chalk.green(`TypeScript types were output at "${argv.output}"`)
+      );
+    }
+  )
+  .demandCommand(1)
+  .parse();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"cli.js","sourceRoot":"","sources":["../lib/cli.ts"],"names":[],"mappings":"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","sourcesContent":["#!/usr/bin/env -S node --experimental-specifier-resolution=node\n\nimport yargs from 'yargs';\nimport { hideBin } from 'yargs/helpers';\nimport chalk from 'chalk';\nimport ora from 'ora';\nimport { ConfigValidator } from './index';\nimport * as fs from 'fs';\nimport JsonBigIntFactory from 'json-bigint';\nimport * as yaml from 'js-yaml';\n\nconst JsonBigInt = JsonBigIntFactory({\n  alwaysParseAsBig: false,\n  useNativeBigInt: true,\n});\n\nyargs(hideBin(process.argv))\n  .command(\n    'generate-default',\n    'generates an object using the default values of the passed schema',\n    (yargs) =>\n      yargs\n        .option('schema', {\n          alias: 's',\n          demandOption: true,\n          description: 'input schema file path which should be in json format',\n          type: 'string',\n        })\n        .option('output', {\n          alias: 'o',\n          demandOption: true,\n          description: 'generated default values output path',\n          type: 'string',\n        })\n        .option('format', {\n          alias: 'f',\n          demandOption: true,\n          description: 'generated default values output path',\n          choices: ['json', 'yaml'],\n          default: 'yaml',\n          type: 'string',\n        }),\n    async (argv) => {\n      const spinner = ora();\n      spinner.start(`Generating config default values`);\n\n      const rawSchemaData = fs.readFileSync(argv.schema, 'utf-8');\n      const schema = JsonBigInt.parse(rawSchemaData);\n\n      const confValidator = new ConfigValidator(schema);\n      const defaultConf = confValidator.generateDefault();\n\n      let output = '';\n      switch (argv.format) {\n        case 'json': {\n          output = JsonBigInt.stringify(defaultConf);\n          break;\n        }\n        case 'yaml': {\n          output = yaml.dump(defaultConf);\n          break;\n        }\n      }\n\n      fs.writeFileSync(argv.output, output);\n\n      spinner.succeed(\n        chalk.green(`default config values were output at \"${argv.output}\"`)\n      );\n    }\n  )\n  .command(\n    'generate-ts-types',\n    'generates compatible TypeScript interface types for the passed schema',\n    (yargs) =>\n      yargs\n        .option('schema', {\n          alias: 's',\n          demandOption: true,\n          description: 'input schema file path which should be in json format',\n          type: 'string',\n        })\n        .option('output', {\n          alias: 'o',\n          demandOption: true,\n          description: 'generated TypeScript interfaces',\n          type: 'string',\n        })\n        .option('root-type', {\n          alias: 'r',\n          demandOption: true,\n          description: 'Name of top root interface',\n          type: 'string',\n        }),\n    async (argv) => {\n      const spinner = ora();\n      spinner.start(`Generating TypeScript types`);\n\n      const rawSchemaData = fs.readFileSync(argv.schema, 'utf-8');\n      const schema = JsonBigInt.parse(rawSchemaData);\n\n      const confValidator = new ConfigValidator(schema);\n      const tsTypes = confValidator.generateTSTypes(argv.rootType);\n\n      fs.writeFileSync(argv.output, tsTypes);\n\n      spinner.succeed(\n        chalk.green(`TypeScript types were output at \"${argv.output}\"`)\n      );\n    }\n  )\n  .demandCommand(1)\n  .parse();\n"]}

package/dist/config.d.ts

@@ -0,0 +1,131 @@
+import { IConfig } from 'config';
+import { ConfigField, ConfigSchema } from './schema/types/fields';
+import { When } from './schema/types/validations';
+export declare class ConfigValidator {
+  private schema;
+  constructor(schema: ConfigSchema);
+  /**
+   * validates the passed config against the instance's schema
+   *
+   * @param {Record<string, any>} config
+   */
+  validateConfig(config: Record<string, any>): void;
+  /**
+   * validates a value in config object
+   *
+   * @private
+   * @param {*} value
+   * @param {ConfigField} field the field specification in schema
+   * @param {Record<string, any>} config the config object
+   */
+  private validateValue;
+  /**
+   * determines if a when clause in validations section of a schema field is
+   * satisfied
+   *
+   * @param {When} when
+   * @param {Record<string, any>} config
+   * @return {boolean}
+   */
+  isWhenTrue: (when: When, config: Record<string, any>) => boolean;
+  /**
+   * returns the value at specified path in config object
+   *
+   * @static
+   * @param {Record<string, any>} config
+   * @param {string[]} path
+   * @return {*}
+   */
+  static valueAt: (config: Record<string, any>, path: string[]) => any;
+  /**
+   * validates this.schema and throws exception if any errors found
+   */
+  private validateSchema;
+  /**
+   * validates config key name
+   *
+   * @param {string} name
+   */
+  private validateConfigName;
+  /**
+   * validates passed schema field structure
+   *
+   * @param {ConfigField} field
+   */
+  private validateSchemaField;
+  /**
+   * returns a field corresponding to a path in schema tree
+   *
+   * @param {string[]} path
+   * @return {(ConfigField | undefined)} returns undefined if field is not found
+   */
+  getSchemaField: (path: string[]) => ConfigField | undefined;
+  /**
+   * extracts default values from a schema
+   *
+   * @return {Record<string, any>} object of default values
+   */
+  generateDefault: () => Record<string, any>;
+  /**
+   * generates compatible TypeScript interface for this instance's schema
+   *
+   * @param {string} name the name of root type
+   * @return {string}
+   */
+  generateTSTypes: (name: string) => string;
+  /**
+   * generates a TypeScript interface definition for passed name and attributes
+   *
+   * @param {string} name
+   * @param {Array<[string, string]>} attributes
+   * @return {string}
+   */
+  private genTSInterface;
+  /**
+   * returns a characteristic object for values at a specific node config level
+   *
+   * @param {IConfig} config
+   * @param {string} level
+   * @return {Record<string, any>}
+   */
+  getConfigForLevel(config: IConfig, level: string): Record<string, any>;
+  /**
+   *traverses the config schema depth first to produce characteristic object
+   *
+   * @private
+   * @static
+   * @param {ConfigSchema} schema
+   * @param {string[]} path
+   * @param {IConfigSource[]} higherLevelSources
+   * @param {(IConfigSource | undefined)} currentLevelSource
+   * @param {IConfigSource[]} lowerLevelSources
+   * @return {Record<string, any>}
+   * @memberof ConfigValidator
+   */
+  private static processConfigForLevelNode;
+  /**
+   * returns a list of config sources used by node config package, ordered from
+   * the lowest to the highest priority
+   *
+   * @static
+   * @param {IConfig} config
+   * @return  {string[]}
+   */
+  private static getNodeConfigLevels;
+  /**
+   * validates a config object and writes it to the node-config file
+   * corresponding to the passed level
+   *
+   * @param {Record<string, any>} configObj
+   * @param {IConfig} config
+   * @param {string} level output node-config file level
+   * @param {string} format the format of the output file
+   */
+  validateAndWriteConfig: (
+    configObj: Record<string, any>,
+    config: IConfig,
+    level: string,
+    format: string
+  ) => void;
+}
+//# sourceMappingURL=config.d.ts.map

package/dist/config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../lib/config.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAiB,MAAM,QAAQ,CAAC;AAShD,OAAO,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAC;AAClE,OAAO,EAAE,IAAI,EAAE,MAAM,4BAA4B,CAAC;AAIlD,qBAAa,eAAe;IACd,OAAO,CAAC,MAAM;gBAAN,MAAM,EAAE,YAAY;IAIxC;;;;OAIG;IACI,cAAc,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC;IAsDjD;;;;;;;OAOG;IACH,OAAO,CAAC,aAAa,CA+BnB;IAEF;;;;;;;OAOG;IACI,UAAU,SAAU,IAAI,UAAU,OAAO,MAAM,EAAE,GAAG,CAAC,KAAG,OAAO,CAIpE;IAEF;;;;;;;OAOG;IACH,MAAM,CAAC,OAAO,WAAY,OAAO,MAAM,EAAE,GAAG,CAAC,QAAQ,MAAM,EAAE,SAW3D;IAEF;;OAEG;IACH,OAAO,CAAC,cAAc,CAkDpB;IAEF;;;;OAIG;IACH,OAAO,CAAC,kBAAkB,CAIxB;IAEF;;;;OAIG;IACH,OAAO,CAAC,mBAAmB,CA2BzB;IAEF;;;;;OAKG;IACH,cAAc,SAAU,MAAM,EAAE,KAAG,WAAW,GAAG,SAAS,CAYxD;IAEF;;;;OAIG;IACH,eAAe,QAAO,OAAO,MAAM,EAAE,GAAG,CAAC,CAuDvC;IAEF;;;;;OAKG;IACH,eAAe,SAAU,MAAM,KAAG,MAAM,CAwEtC;IAEF;;;;;;OAMG;IACH,OAAO,CAAC,cAAc,CAOpB;IAEF;;;;;;OAMG;IACH,iBAAiB,CAAC,MAAM,EAAE,OAAO,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC;IAmCtE;;;;;;;;;;;;OAYG;IACH,OAAO,CAAC,MAAM,CAAC,yBAAyB;IA6CxC;;;;;;;OAOG;IACH,OAAO,CAAC,MAAM,CAAC,mBAAmB,CAkDhC;IAEF;;;;;;;;OAQG;IACH,sBAAsB,cACT,OAAO,MAAM,EAAE,GAAG,CAAC,UACtB,OAAO,SACR,MAAM,UACL,MAAM,UAyDd;CACH"}