@rosen-bridge/config 0.3.0 → 1.0.0

package/lib/index.ts

@@ -1 +0,0 @@
-export * from './config';

package/lib/schema/Validators/fieldProperties.ts

@@ -1,291 +0,0 @@
-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) => {
-      if (
-        !Object.hasOwn(field, 'children') ||
-        typeof field.children !== 'object'
-      ) {
-        throw new Error(
-          `object field type must have a "children" property of type "object"`
-        );
-      }
-      return;
-    },
-  },
-  array: {
-    items: (field: types.ArrayField, config: ConfigValidator) => {
-      if (!Object.hasOwn(field, 'items') || typeof field.items !== 'object') {
-        throw new Error(
-          `array field type must have a "items" property of type "object"`
-        );
-      }
-    },
-  },
-  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"`
-          );
-        }
-      }
-    },
-  },
-  boolean: {},
-  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

@@ -1,53 +0,0 @@
-import { VBoolean, VNumeric, VString } from './validations';
-
-export type PrimitiveValue = string | boolean | number | bigint;
-
-export type ConfigSchema = Record<string, ConfigField>;
-
-export type ConfigField = ObjectField | ArrayField | PrimitiveField;
-
-export type PrimitiveField =
-  | StringField
-  | NumberField
-  | BigIntField
-  | BooleanField;
-
-export interface ObjectField {
-  type: 'object';
-  description?: string;
-  label?: string;
-  children: ConfigSchema;
-}
-
-export interface ArrayField {
-  type: 'array';
-  description?: string;
-  label?: string;
-  items: ConfigField;
-}
-
-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

@@ -1,63 +0,0 @@
-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

@@ -1,68 +0,0 @@
-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;
-};