@rosen-bridge/config 0.1.0

package/dist/value/validators.js

@@ -0,0 +1,188 @@
+export const valueValidators = {
+  object: (value, field) => {
+    if (typeof value !== 'object') {
+      throw new Error(`value must be of object type`);
+    }
+    const schemaKeys = new Set(Object.keys(field.children));
+    for (const key of Object.keys(value)) {
+      if (!schemaKeys.has(key)) {
+        throw new Error(`"${key}" key is not found in the schema`);
+      }
+    }
+  },
+  string: (value, field) => {
+    if (typeof value !== 'string') {
+      throw new Error(`value must be of string type`);
+    }
+  },
+  boolean: (value, field) => {
+    if (typeof value !== 'boolean') {
+      throw new Error(`value must be of boolean type`);
+    }
+  },
+  number: (value, field) => {
+    if (typeof value !== 'number') {
+      throw new Error(`value must be of number type`);
+    }
+  },
+  bigint: (value, field) => {
+    if (typeof value !== 'bigint') {
+      throw new Error(`value must be of bigint type`);
+    }
+  },
+};
+const required = (value, validation, config, configValidator) => {
+  if (validation.when && !configValidator.isWhenTrue(validation.when, config)) {
+    return;
+  }
+  if (validation.required && value == undefined) {
+    throw new Error('value is required but not found in config');
+  }
+};
+export const valueValidations = {
+  boolean: { required },
+  string: {
+    required,
+    regex: (value, validation, config, configValidator) => {
+      if (
+        value == undefined ||
+        (validation.when &&
+          !configValidator.isWhenTrue(validation.when, config))
+      ) {
+        return;
+      }
+      const re = new RegExp(validation.regex);
+      const match = value.match(re);
+      if (match == null || match[0] !== value) {
+        throw new Error(`value should match the regex="${validation.regex}"`);
+      }
+    },
+    choices: (value, validation, config, configValidator) => {
+      if (
+        value == undefined ||
+        (validation.when &&
+          !configValidator.isWhenTrue(validation.when, config))
+      ) {
+        return;
+      }
+      if (!validation.choices.includes(value)) {
+        throw new Error(
+          `value should be one of the choices=[${validation.choices.join(
+            ', '
+          )}]`
+        );
+      }
+    },
+  },
+  number: {
+    required,
+    gt: (value, validation, config, configValidator) => {
+      if (
+        value == undefined ||
+        (validation.when &&
+          !configValidator.isWhenTrue(validation.when, config))
+      ) {
+        return;
+      }
+      if (value <= validation.gt) {
+        throw new Error(`value should be greater than ${validation.gt}`);
+      }
+    },
+    gte: (value, validation, config, configValidator) => {
+      if (
+        value == undefined ||
+        (validation.when &&
+          !configValidator.isWhenTrue(validation.when, config))
+      ) {
+        return;
+      }
+      if (value < validation.gte) {
+        throw new Error(
+          `value should be greater than or equal to ${validation.gte}`
+        );
+      }
+    },
+    lt: (value, validation, config, configValidator) => {
+      if (
+        value == undefined ||
+        (validation.when &&
+          !configValidator.isWhenTrue(validation.when, config))
+      ) {
+        return;
+      }
+      if (value >= validation.lt) {
+        throw new Error(`value should be less than ${validation.lt}`);
+      }
+    },
+    lte: (value, validation, config, configValidator) => {
+      if (
+        value == undefined ||
+        (validation.when &&
+          !configValidator.isWhenTrue(validation.when, config))
+      ) {
+        return;
+      }
+      if (value > validation.lte) {
+        throw new Error(
+          `value should be less than or equal to ${validation.lte}`
+        );
+      }
+    },
+  },
+  bigint: {
+    required,
+    gt: (value, validation, config, configValidator) => {
+      if (
+        value == undefined ||
+        (validation.when &&
+          !configValidator.isWhenTrue(validation.when, config))
+      ) {
+        return;
+      }
+      if (value <= validation.gt) {
+        throw new Error(`value should be greater than ${validation.gt}`);
+      }
+    },
+    gte: (value, validation, config, configValidator) => {
+      if (
+        value == undefined ||
+        (validation.when &&
+          !configValidator.isWhenTrue(validation.when, config))
+      ) {
+        return;
+      }
+      if (value < validation.gte) {
+        throw new Error(
+          `value should be greater than or equal to ${validation.gte}`
+        );
+      }
+    },
+    lt: (value, validation, config, configValidator) => {
+      if (
+        value == undefined ||
+        (validation.when &&
+          !configValidator.isWhenTrue(validation.when, config))
+      ) {
+        return;
+      }
+      if (value >= validation.lt) {
+        throw new Error(`value should be less than ${validation.lt}`);
+      }
+    },
+    lte: (value, validation, config, configValidator) => {
+      if (
+        value == undefined ||
+        (validation.when &&
+          !configValidator.isWhenTrue(validation.when, config))
+      ) {
+        return;
+      }
+      if (value > validation.lte) {
+        throw new Error(
+          `value should be less than or equal to ${validation.lte}`
+        );
+      }
+    },
+  },
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"validators.js","sourceRoot":"","sources":["../../lib/value/validators.ts"],"names":[],"mappings":"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","sourcesContent":["import { ConfigValidator } from '../config';\nimport * as types from '../schema/types/fields';\nimport {\n  VChoices,\n  VGreater,\n  VGreaterEqual,\n  VLess,\n  VLessEqual,\n  VRegex,\n  VRequired,\n} from '../schema/types/validations';\n\nexport const valueValidators: Record<string, any> = {\n  object: (value: Record<string, any>, field: types.ObjectField) => {\n    if (typeof value !== 'object') {\n      throw new Error(`value must be of object type`);\n    }\n\n    const schemaKeys = new Set(Object.keys(field.children));\n    for (const key of Object.keys(value)) {\n      if (!schemaKeys.has(key)) {\n        throw new Error(`\"${key}\" key is not found in the schema`);\n      }\n    }\n  },\n  string: (value: string, field: types.StringField) => {\n    if (typeof value !== 'string') {\n      throw new Error(`value must be of string type`);\n    }\n  },\n  boolean: (value: boolean, field: types.BooleanField) => {\n    if (typeof value !== 'boolean') {\n      throw new Error(`value must be of boolean type`);\n    }\n  },\n  number: (value: number, field: types.NumberField) => {\n    if (typeof value !== 'number') {\n      throw new Error(`value must be of number type`);\n    }\n  },\n  bigint: (value: bigint, field: types.BigIntField) => {\n    if (typeof value !== 'bigint') {\n      throw new Error(`value must be of bigint type`);\n    }\n  },\n};\n\nconst required = (\n  value: any,\n  validation: VRequired,\n  config: Record<string, any>,\n  configValidator: ConfigValidator\n) => {\n  if (validation.when && !configValidator.isWhenTrue(validation.when, config)) {\n    return;\n  }\n\n  if (validation.required && value == undefined) {\n    throw new Error('value is required but not found in config');\n  }\n};\n\nexport const valueValidations: Record<string, Record<string, any>> = {\n  boolean: { required },\n  string: {\n    required,\n    regex: (\n      value: string,\n      validation: VRegex,\n      config: Record<string, any>,\n      configValidator: ConfigValidator\n    ) => {\n      if (\n        value == undefined ||\n        (validation.when &&\n          !configValidator.isWhenTrue(validation.when, config))\n      ) {\n        return;\n      }\n\n      const re = new RegExp(validation.regex);\n      const match = value.match(re);\n      if (match == null || match[0] !== value) {\n        throw new Error(`value should match the regex=\"${validation.regex}\"`);\n      }\n    },\n    choices: (\n      value: string,\n      validation: VChoices,\n      config: Record<string, any>,\n      configValidator: ConfigValidator\n    ) => {\n      if (\n        value == undefined ||\n        (validation.when &&\n          !configValidator.isWhenTrue(validation.when, config))\n      ) {\n        return;\n      }\n\n      if (!validation.choices.includes(value)) {\n        throw new Error(\n          `value should be one of the choices=[${validation.choices.join(\n            ', '\n          )}]`\n        );\n      }\n    },\n  },\n  number: {\n    required,\n    gt: (\n      value: number,\n      validation: VGreater<number>,\n      config: Record<string, any>,\n      configValidator: ConfigValidator\n    ) => {\n      if (\n        value == undefined ||\n        (validation.when &&\n          !configValidator.isWhenTrue(validation.when, config))\n      ) {\n        return;\n      }\n\n      if (value <= validation.gt) {\n        throw new Error(`value should be greater than ${validation.gt}`);\n      }\n    },\n    gte: (\n      value: number,\n      validation: VGreaterEqual<number>,\n      config: Record<string, any>,\n      configValidator: ConfigValidator\n    ) => {\n      if (\n        value == undefined ||\n        (validation.when &&\n          !configValidator.isWhenTrue(validation.when, config))\n      ) {\n        return;\n      }\n\n      if (value < validation.gte) {\n        throw new Error(\n          `value should be greater than or equal to ${validation.gte}`\n        );\n      }\n    },\n    lt: (\n      value: number,\n      validation: VLess<number>,\n      config: Record<string, any>,\n      configValidator: ConfigValidator\n    ) => {\n      if (\n        value == undefined ||\n        (validation.when &&\n          !configValidator.isWhenTrue(validation.when, config))\n      ) {\n        return;\n      }\n\n      if (value >= validation.lt) {\n        throw new Error(`value should be less than ${validation.lt}`);\n      }\n    },\n    lte: (\n      value: number,\n      validation: VLessEqual<number>,\n      config: Record<string, any>,\n      configValidator: ConfigValidator\n    ) => {\n      if (\n        value == undefined ||\n        (validation.when &&\n          !configValidator.isWhenTrue(validation.when, config))\n      ) {\n        return;\n      }\n\n      if (value > validation.lte) {\n        throw new Error(\n          `value should be less than or equal to ${validation.lte}`\n        );\n      }\n    },\n  },\n  bigint: {\n    required,\n    gt: (\n      value: bigint,\n      validation: VGreater<bigint>,\n      config: Record<string, any>,\n      configValidator: ConfigValidator\n    ) => {\n      if (\n        value == undefined ||\n        (validation.when &&\n          !configValidator.isWhenTrue(validation.when, config))\n      ) {\n        return;\n      }\n\n      if (value <= validation.gt) {\n        throw new Error(`value should be greater than ${validation.gt}`);\n      }\n    },\n    gte: (\n      value: bigint,\n      validation: VGreaterEqual<bigint>,\n      config: Record<string, any>,\n      configValidator: ConfigValidator\n    ) => {\n      if (\n        value == undefined ||\n        (validation.when &&\n          !configValidator.isWhenTrue(validation.when, config))\n      ) {\n        return;\n      }\n\n      if (value < validation.gte) {\n        throw new Error(\n          `value should be greater than or equal to ${validation.gte}`\n        );\n      }\n    },\n    lt: (\n      value: bigint,\n      validation: VLess<bigint>,\n      config: Record<string, any>,\n      configValidator: ConfigValidator\n    ) => {\n      if (\n        value == undefined ||\n        (validation.when &&\n          !configValidator.isWhenTrue(validation.when, config))\n      ) {\n        return;\n      }\n\n      if (value >= validation.lt) {\n        throw new Error(`value should be less than ${validation.lt}`);\n      }\n    },\n    lte: (\n      value: bigint,\n      validation: VLessEqual<bigint>,\n      config: Record<string, any>,\n      configValidator: ConfigValidator\n    ) => {\n      if (\n        value == undefined ||\n        (validation.when &&\n          !configValidator.isWhenTrue(validation.when, config))\n      ) {\n        return;\n      }\n\n      if (value > validation.lte) {\n        throw new Error(\n          `value should be less than or equal to ${validation.lte}`\n        );\n      }\n    },\n  },\n};\n"]}

package/lib/cli.ts

@@ -0,0 +1,113 @@
+#!/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();