@rosen-bridge/config 0.1.0

package/lib/schema/Validators/fieldProperties.ts

@@ -0,0 +1,273 @@
+import { ConfigValidator } from '../../config';
+import * as types from '../types/fields';
+import { VAll, VNumeric, VString } from '../types/validations';
+
+export const propertyValidators = {
+  all: {
+    type: (field: types.ConfigField, config: ConfigValidator) => {
+      if (!Object.hasOwn(field, 'type') || typeof field.type !== 'string') {
+        throw new Error(
+          `every schema field must have a "type" property of type "string"`
+        );
+      }
+
+      if (!supportedTypes.includes(field.type)) {
+        throw new Error(`unsupported field type "${field.type}"`);
+      }
+    },
+    label: (field: types.ConfigField, config: ConfigValidator) => {
+      if (Object.hasOwn(field, 'label') && typeof field.label !== 'string') {
+        throw new Error(`"label" property should be a "string"`);
+      }
+    },
+    description: (field: types.ConfigField, config: ConfigValidator) => {
+      if (
+        Object.hasOwn(field, 'description') &&
+        typeof field.description !== 'string'
+      ) {
+        throw new Error(`"description" property should be a "string"`);
+      }
+    },
+  },
+  primitive: {
+    validations: (field: types.PrimitiveField, config: ConfigValidator) => {
+      if (!Object.hasOwn(field, 'validations')) {
+        return;
+      }
+
+      if (!Array.isArray(field.validations)) {
+        throw new Error(
+          '"validations" property must be an array of validation descriptions'
+        );
+      }
+
+      for (const validation of field.validations) {
+        if (
+          Object.hasOwn(validation, 'error') &&
+          typeof validation.error !== 'string'
+        ) {
+          throw new Error(
+            '"error" property of a validation description must be a string'
+          );
+        }
+
+        if (Object.hasOwn(validation, 'when') && validation.when != undefined) {
+          if (
+            !Object.hasOwn(validation.when, 'path') ||
+            typeof validation.when.path !== 'string'
+          ) {
+            throw new Error(
+              `"when" property of a validation description must have a "path" property of type "string"`
+            );
+          }
+
+          if (
+            config.getSchemaField(validation.when.path.split('.')) == undefined
+          ) {
+            throw new Error(
+              `"when" property of a validation description has a non-existent path=[${validation.when.path}]`
+            );
+          }
+
+          if (!Object.hasOwn(validation.when, 'value')) {
+            throw new Error(
+              `"when" property of a validation description must have a "value" property`
+            );
+          }
+        }
+
+        const validationProperties = Object.keys(validation).filter(
+          (key) => key !== 'when' && key !== 'error'
+        );
+        if (validationProperties.length !== 1) {
+          throw new Error('validation description format is wrong');
+        }
+
+        const validationName = validationProperties[0];
+        const primitiveValidator = fieldValidations.primitive[validationName];
+        const typeValidator = fieldValidations[field.type][validationName];
+        if (primitiveValidator == undefined && typeValidator == undefined) {
+          throw new Error(
+            `validation description has an unknown validator "${validationName}"`
+          );
+        }
+
+        if (primitiveValidator != undefined) {
+          primitiveValidator(validation);
+        } else {
+          typeValidator(validation);
+        }
+      }
+    },
+  },
+  object: {
+    children: (field: types.ObjectField, config: ConfigValidator) => {
+      return;
+    },
+  },
+  string: {
+    default: (field: types.StringField, config: ConfigValidator) => {
+      if (
+        Object.hasOwn(field, 'default') &&
+        typeof field.default !== 'string'
+      ) {
+        throw new Error(
+          `default value=[${field.default}] doesn't match field type=[${field.type}]`
+        );
+      }
+    },
+  },
+  boolean: {
+    default: (field: types.BooleanField, config: ConfigValidator) => {
+      if (
+        Object.hasOwn(field, 'default') &&
+        typeof field.default !== 'boolean'
+      ) {
+        throw new Error(
+          `default value=[${field.default}] doesn't match field type=[${field.type}]`
+        );
+      }
+    },
+  },
+  number: {
+    default: (field: types.NumberField, config: ConfigValidator) => {
+      if (
+        Object.hasOwn(field, 'default') &&
+        typeof field.default !== 'number'
+      ) {
+        throw new Error(
+          `default value=[${field.default}] doesn't match field type=[${field.type}]`
+        );
+      }
+    },
+  },
+  bigint: {
+    default: (field: types.BigIntField, config: ConfigValidator) => {
+      if (
+        Object.hasOwn(field, 'default') &&
+        typeof field.default !== 'bigint'
+      ) {
+        throw new Error(
+          `default value=[${field.default}] doesn't match field type=[${field.type}]`
+        );
+      }
+    },
+  },
+};
+
+export const supportedTypes = Object.keys(propertyValidators).filter(
+  (key) => key !== 'all' && key !== 'primitive'
+);
+
+const fieldValidations: Record<string, Record<string, any>> = {
+  primitive: {
+    required: (validation: VAll) => {
+      if (!('required' in validation)) {
+        return;
+      }
+
+      if (typeof validation.required !== 'boolean') {
+        throw new Error(`"required" validation property should be a boolean`);
+      }
+    },
+  },
+  string: {
+    regex: (validation: VString) => {
+      if (!('regex' in validation)) {
+        return;
+      }
+      if (typeof validation.regex !== 'string') {
+        throw new Error(`"regex" validation property should be a string`);
+      }
+    },
+    choices: (validation: VString) => {
+      if (!('choices' in validation)) {
+        return;
+      }
+      if (!Array.isArray(validation.choices)) {
+        throw new Error(
+          `"choices" validation property should be an "array" of strings`
+        );
+      }
+
+      for (const choice of validation.choices) {
+        if (typeof choice !== 'string') {
+          throw new Error(
+            `"choices" validation property should be an array of "strings"`
+          );
+        }
+      }
+    },
+  },
+  number: {
+    gt: (validation: VNumeric<number>) => {
+      if (!('gt' in validation)) {
+        return;
+      }
+      if (typeof validation.gt !== 'number') {
+        throw new Error(`"gt" validation property should be a number`);
+      }
+    },
+    gte: (validation: VNumeric<number>) => {
+      if (!('gte' in validation)) {
+        return;
+      }
+      if (typeof validation.gte !== 'number') {
+        throw new Error(`"gte" validation property should be a number`);
+      }
+    },
+    lt: (validation: VNumeric<number>) => {
+      if (!('lt' in validation)) {
+        return;
+      }
+
+      if (typeof validation.lt !== 'number') {
+        throw new Error(`"lt" validation property should be a number`);
+      }
+    },
+    lte: (validation: VNumeric<number>) => {
+      if (!('lte' in validation)) {
+        return;
+      }
+
+      if (typeof validation.lte !== 'number') {
+        throw new Error(`"lte" validation property should be a number`);
+      }
+    },
+  },
+  bigint: {
+    gt: (validation: VNumeric<bigint>) => {
+      if (!('gt' in validation)) {
+        return;
+      }
+
+      if (typeof validation.gt !== 'bigint') {
+        throw new Error(`"gt" validation property should be a bigint`);
+      }
+    },
+    gte: (validation: VNumeric<bigint>) => {
+      if (!('gte' in validation)) {
+        return;
+      }
+      if (typeof validation.gte !== 'bigint') {
+        throw new Error(`"gte" validation property should be a bigint`);
+      }
+    },
+    lt: (validation: VNumeric<bigint>) => {
+      if (!('lt' in validation)) {
+        return;
+      }
+      if (typeof validation.lt !== 'bigint') {
+        throw new Error(`"lt" validation property should be a bigint`);
+      }
+    },
+    lte: (validation: VNumeric<bigint>) => {
+      if (!('lte' in validation)) {
+        return;
+      }
+      if (typeof validation.lte !== 'bigint') {
+        throw new Error(`"lte" validation property should be a bigint`);
+      }
+    },
+  },
+};

package/lib/schema/types/fields.ts

@@ -0,0 +1,46 @@
+import { VBoolean, VNumeric, VString } from './validations';
+
+export type PrimitiveValue = string | boolean | number | bigint;
+
+export type ConfigSchema = Record<string, ConfigField>;
+
+export type ConfigField = ObjectField | PrimitiveField;
+
+export type PrimitiveField =
+  | StringField
+  | NumberField
+  | BigIntField
+  | BooleanField;
+
+export interface ObjectField {
+  type: 'object';
+  description?: string;
+  label?: string;
+  children: ConfigSchema;
+}
+
+export interface GenericField<T> {
+  default?: T;
+  description?: string;
+  label?: string;
+}
+
+export interface StringField extends GenericField<string> {
+  type: 'string';
+  validations?: VString[];
+}
+
+export interface NumberField extends GenericField<number> {
+  type: 'number';
+  validations?: VNumeric<number>[];
+}
+
+export interface BigIntField extends GenericField<bigint> {
+  type: 'bigint';
+  validations?: VNumeric<bigint>[];
+}
+
+export interface BooleanField extends GenericField<boolean> {
+  type: 'boolean';
+  validations?: VBoolean[];
+}

package/lib/schema/types/validations.ts

@@ -0,0 +1,63 @@
+import { PrimitiveValue } from './fields';
+
+export type Validation =
+  | VAll
+  | VString
+  | VBoolean
+  | VNumeric<number>
+  | VNumeric<bigint>;
+
+export interface When {
+  path: string;
+  value: PrimitiveValue;
+}
+
+export interface VGeneric {
+  error?: string;
+  when?: When;
+}
+
+// validators for all types
+export type VAll = VRequired;
+
+export interface VRequired extends VGeneric {
+  required: boolean;
+}
+
+// string validators
+export type VString = VAll | VRegex | VChoices;
+
+export interface VRegex extends VGeneric {
+  regex: string;
+}
+
+export interface VChoices extends VGeneric {
+  choices: string[];
+}
+
+// boolean validators
+export type VBoolean = VAll;
+
+// numeric validators
+export type VNumeric<T extends number | bigint> =
+  | VAll
+  | VGreater<T>
+  | VGreaterEqual<T>
+  | VLess<T>
+  | VLessEqual<T>;
+
+export interface VGreater<T extends number | bigint> extends VGeneric {
+  gt: T;
+}
+
+export interface VGreaterEqual<T extends number | bigint> extends VGeneric {
+  gte: T;
+}
+
+export interface VLess<T extends number | bigint> extends VGeneric {
+  lt: T;
+}
+
+export interface VLessEqual<T extends number | bigint> extends VGeneric {
+  lte: T;
+}

package/lib/utils.ts

@@ -0,0 +1,68 @@
+import { IConfigSource } from 'config';
+import path from 'path';
+
+/**
+ * returns the value at a path in the passed object, and if it has a value
+ * defined at that path
+ *
+ * @param {*} obj
+ * @param {string[]} path path to the value to be returned
+ * @return {{ defined: boolean; value: any }}
+ */
+export const getValue = (
+  obj: any,
+  path: string[]
+): { defined: boolean; value: any } => {
+  let value = obj;
+  for (const key of path) {
+    if (value != undefined && Object.hasOwn(value, key)) {
+      value = value[key];
+    } else {
+      return { defined: false, value: undefined };
+    }
+  }
+  return { defined: true, value };
+};
+
+/**
+ * returns source name/level for a node config source
+ *
+ * @export
+ * @param {IConfigSource} source
+ * @return {string}
+ */
+export const getSourceName = (source: IConfigSource): string => {
+  return source.name.startsWith('$')
+    ? source.name
+    : path.parse(source.name).name;
+};
+
+/**
+ * returns a config key from the highest level source in an array of sources
+ *
+ * @param {IConfigSource[]} sources
+ * @param {string[]} path
+ * @return {*}
+ */
+export const getValueFromConfigSources = (
+  sources: IConfigSource[],
+  path: string[]
+) => {
+  for (let i = sources.length - 1; i >= 0; i--) {
+    const source = sources[i];
+    if (getSourceName(source) === 'custom-environment-variables') {
+      const { value: envVar, defined } = getValue(source.parsed, path);
+      if (defined) {
+        if (process.env[envVar] != undefined) {
+          return process.env[envVar];
+        }
+      }
+    } else {
+      const { value, defined } = getValue(source.parsed, path);
+      if (defined) {
+        return value;
+      }
+    }
+  }
+  return null;
+};

package/lib/value/validators.ts

@@ -0,0 +1,268 @@
+import { ConfigValidator } from '../config';
+import * as types from '../schema/types/fields';
+import {
+  VChoices,
+  VGreater,
+  VGreaterEqual,
+  VLess,
+  VLessEqual,
+  VRegex,
+  VRequired,
+} from '../schema/types/validations';
+
+export const valueValidators: Record<string, any> = {
+  object: (value: Record<string, any>, field: types.ObjectField) => {
+    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: string, field: types.StringField) => {
+    if (typeof value !== 'string') {
+      throw new Error(`value must be of string type`);
+    }
+  },
+  boolean: (value: boolean, field: types.BooleanField) => {
+    if (typeof value !== 'boolean') {
+      throw new Error(`value must be of boolean type`);
+    }
+  },
+  number: (value: number, field: types.NumberField) => {
+    if (typeof value !== 'number') {
+      throw new Error(`value must be of number type`);
+    }
+  },
+  bigint: (value: bigint, field: types.BigIntField) => {
+    if (typeof value !== 'bigint') {
+      throw new Error(`value must be of bigint type`);
+    }
+  },
+};
+
+const required = (
+  value: any,
+  validation: VRequired,
+  config: Record<string, any>,
+  configValidator: 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: Record<string, Record<string, any>> = {
+  boolean: { required },
+  string: {
+    required,
+    regex: (
+      value: string,
+      validation: VRegex,
+      config: Record<string, any>,
+      configValidator: 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: string,
+      validation: VChoices,
+      config: Record<string, any>,
+      configValidator: 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: number,
+      validation: VGreater<number>,
+      config: Record<string, any>,
+      configValidator: 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: number,
+      validation: VGreaterEqual<number>,
+      config: Record<string, any>,
+      configValidator: 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: number,
+      validation: VLess<number>,
+      config: Record<string, any>,
+      configValidator: 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: number,
+      validation: VLessEqual<number>,
+      config: Record<string, any>,
+      configValidator: 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: bigint,
+      validation: VGreater<bigint>,
+      config: Record<string, any>,
+      configValidator: 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: bigint,
+      validation: VGreaterEqual<bigint>,
+      config: Record<string, any>,
+      configValidator: 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: bigint,
+      validation: VLess<bigint>,
+      config: Record<string, any>,
+      configValidator: 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: bigint,
+      validation: VLessEqual<bigint>,
+      config: Record<string, any>,
+      configValidator: 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}`
+        );
+      }
+    },
+  },
+};