@rosen-bridge/config 0.1.0 → 0.2.1

package/lib/config.ts

@@ -23,59 +23,93 @@ export class ConfigValidator {
    * @param {Record<string, any>} config
    */
   public validateConfig(config: Record<string, any>) {
-    const errorPreamble = (path: Array<string>) =>
-      `config validation failed for "${path.join('.')}" field`;
-
-    const stack: Array<{
-      subSchema: ConfigSchema;
-      subConfig: Record<string, any> | undefined;
-      parentPath: Array<string>;
-    }> = [
-      {
-        subSchema: this.schema,
-        subConfig: config,
-        parentPath: [],
-      },
-    ];
-
     this.validateValue(
       config,
       { type: 'object', children: this.schema },
       config
     );
 
-    // Traverses the schema object tree depth first in coordination with config
-    // object tree and validate config using the schema
-    while (stack.length > 0) {
-      const { subSchema, subConfig, parentPath } = stack.pop()!;
-      // Process children of current field
-      for (const name of Object.keys(subSchema)) {
-        const path = parentPath.concat([name]);
-        try {
-          const field = subSchema[name];
-          let value = undefined;
-          if (subConfig != undefined && Object.hasOwn(subConfig, name)) {
-            value = subConfig[name];
-          }
+    this.validateSubConfig(config, config, this.schema, []);
+  }
 
-          this.validateValue(value, field, config);
+  /**
+   * traverses and validates a subconfig using the subschema
+   *
+   * @private
+   * @param {Record<string, any>} config
+   * @param {Record<string, any>} subConfig
+   * @param {ConfigSchema} subSchema
+   * @param {string[]} path
+   * @memberof ConfigValidator
+   */
+  private validateSubConfig(
+    config: Record<string, any>,
+    subConfig: Record<string, any>,
+    subSchema: ConfigSchema,
+    path: string[]
+  ) {
+    const errorPreamble = (path: Array<string>) =>
+      `config validation failed for "${path.join('.')}" field`;
+    for (const name of Object.keys(subSchema)) {
+      const childPath = path.concat([name]);
+      try {
+        const field = subSchema[name];
+        let value = undefined;
+        if (subConfig != undefined && Object.hasOwn(subConfig, name)) {
+          value = subConfig[name];
+        }
 
-          // if a node/field is of type object and thus is a subtree, add it to
-          // the stack to be traversed later
-          if (field.type === 'object') {
-            stack.push({
-              subSchema: field.children,
-              subConfig: value,
-              parentPath: path,
-            });
+        this.validateValue(value, field, config);
+
+        // if a node/field is of type object and thus is a subtree, traverse it
+        if (field.type === 'object') {
+          this.validateSubConfig(config, value, field.children, childPath);
+        } else if (field.type === 'array') {
+          if (Array.isArray(value)) {
+            for (const item of value) {
+              ConfigValidator.modifyObject(config, item, childPath);
+              this.validateSubConfig(
+                config,
+                { [name]: item },
+                { [name]: field.items },
+                childPath
+              );
+              ConfigValidator.modifyObject(config, value, childPath);
+            }
           }
-        } catch (error: any) {
-          throw new Error(`${errorPreamble(path)}: ${error.message}`);
         }
+      } catch (error: any) {
+        throw new Error(`${errorPreamble(childPath)}: ${error.message}`);
       }
     }
   }
 
+  /**
+   * sets an object's specific subtree to the specified value
+   *
+   * @static
+   * @param {Record<string, any>} obj
+   * @param {*} newValue
+   * @param {string[]} path
+   * @return {*}
+   * @memberof ConfigValidator
+   */
+  static modifyObject(obj: Record<string, any>, newValue: any, path: string[]) {
+    let value: any = obj;
+    for (const key of path.slice(0, -1)) {
+      if (value != undefined && Object.hasOwn(value, key)) {
+        value = value[key];
+      } else {
+        return;
+      }
+    }
+
+    const lastKey = path.at(-1);
+    if (lastKey != undefined) {
+      value[lastKey] = newValue;
+    }
+  }
+
   /**
    * validates a value in config object
    *
@@ -98,7 +132,11 @@ export class ConfigValidator {
       valueValidators[field.type](value, field);
     }
 
-    if (field.type != 'object' && field.validations) {
+    if (
+      field.type !== 'object' &&
+      field.type !== 'array' &&
+      field.validations
+    ) {
       for (const validation of field.validations) {
         const name = Object.keys(validation).filter(
           (key) => key !== 'when' && key !== 'error'
@@ -199,6 +237,11 @@ export class ConfigValidator {
               subSchema: field.children,
               parentPath: path,
             });
+          } else if (field.type === 'array') {
+            stack.push({
+              subSchema: { [name]: field.items },
+              parentPath: path,
+            });
           }
         } catch (error: any) {
           throw new Error(`${errorPreamble(path)}: ${error.message}`);
@@ -228,7 +271,7 @@ export class ConfigValidator {
       if (
         !Object.hasOwn(propertyValidators.all, key) &&
         !(
-          field.type !== 'object' &&
+          !['object', 'array'].includes(field.type) &&
           Object.hasOwn(propertyValidators.primitive, key)
         ) &&
         !Object.hasOwn(propertyValidators[field.type], key)
@@ -241,7 +284,7 @@ export class ConfigValidator {
       validator(field, this);
     }
 
-    if (field.type !== 'object') {
+    if (field.type !== 'object' && field.type !== 'array') {
       for (const validator of Object.values(propertyValidators.primitive)) {
         validator(field, this);
       }
@@ -264,7 +307,12 @@ export class ConfigValidator {
     for (const part of path) {
       if (subTree != undefined && Object.hasOwn(subTree, part)) {
         field = subTree[part];
-        subTree = 'children' in field ? field.children : undefined;
+        subTree =
+          'children' in field
+            ? field.children
+            : 'items' in field && 'children' in field.items
+            ? field.items.children
+            : undefined;
       } else {
         return undefined;
       }
@@ -326,7 +374,7 @@ export class ConfigValidator {
           fieldName: childName,
           children: Object.keys(field.children).reverse(),
         });
-      } else if (field.default != undefined) {
+      } else if (field.type !== 'array' && field.default != undefined) {
         value[childName] = field.default;
       }
     }
@@ -384,7 +432,10 @@ export class ConfigValidator {
         // if a node/field is of type object and thus is a subtree, add it to
         // the stack to be traversed later. Otherwise it's a leaf and needs no
         // traversal.
-        if (field.type === 'object') {
+        if (
+          field.type === 'object' ||
+          (field.type === 'array' && field.items.type === 'object')
+        ) {
           let childTypeName = `${childName[0].toUpperCase()}${childName.substring(
             1
           )}`;
@@ -394,17 +445,44 @@ export class ConfigValidator {
             childTypeName += typeNameCount.toString();
           }
 
+          const children =
+            field.type === 'array' && field.items.type === 'object'
+              ? field.items.children
+              : field.type === 'object'
+              ? field.children
+              : {};
+
           stack.push({
-            subSchema: field.children,
-            children: Object.keys(field.children).reverse(),
+            subSchema: children,
+            children: Object.keys(children).reverse(),
             parentPath: path,
             typeName: childTypeName,
             attributes: [],
           });
 
-          attributes.push([childName, childTypeName]);
+          attributes.push([
+            childName,
+            field.type === 'array' ? `${childTypeName}[]` : childTypeName,
+          ]);
         } else {
-          attributes.push([childName, field.type]);
+          let fieldType: string =
+            field.type === 'array' ? field.items.type : field.type;
+          let isOptional = true;
+          if (field.type !== 'array' && field.validations != undefined) {
+            for (const validation of field.validations) {
+              if (field.type === 'string' && 'choices' in validation) {
+                fieldType = validation.choices.map((c) => `'${c}'`).join(' | ');
+              }
+
+              if ('required' in validation && !('when' in validation)) {
+                isOptional = false;
+              }
+            }
+          }
+          attributes.push([
+            isOptional ? `${childName}?` : childName,
+            field.type === 'array' ? `${fieldType}[]` : fieldType,
+          ]);
         }
       } catch (error: any) {
         throw new Error(`${errorPreamble(path)}: ${error.message}`);
@@ -425,7 +503,7 @@ export class ConfigValidator {
     name: string,
     attributes: Array<[string, string]>
   ): string => {
-    return `interface ${name} {
+    return `export interface ${name} {
   ${attributes.map((attr) => `${attr[0]}: ${attr[1]};`).join('\n  ')}
 }`;
   };

package/lib/schema/Validators/fieldProperties.ts

@@ -102,9 +102,26 @@ export const propertyValidators = {
   },
   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 (
@@ -199,6 +216,7 @@ const fieldValidations: Record<string, Record<string, any>> = {
       }
     },
   },
+  boolean: {},
   number: {
     gt: (validation: VNumeric<number>) => {
       if (!('gt' in validation)) {

package/lib/schema/types/fields.ts

@@ -4,7 +4,7 @@ export type PrimitiveValue = string | boolean | number | bigint;
 
 export type ConfigSchema = Record<string, ConfigField>;
 
-export type ConfigField = ObjectField | PrimitiveField;
+export type ConfigField = ObjectField | ArrayField | PrimitiveField;
 
 export type PrimitiveField =
   | StringField
@@ -19,6 +19,13 @@ export interface ObjectField {
   children: ConfigSchema;
 }
 
+export interface ArrayField {
+  type: 'array';
+  description?: string;
+  label?: string;
+  items: ConfigField;
+}
+
 export interface GenericField<T> {
   default?: T;
   description?: string;

package/lib/value/validators.ts

@@ -23,6 +23,11 @@ export const valueValidators: Record<string, any> = {
       }
     }
   },
+  array: (value: Array<any>, field: types.ArrayField) => {
+    if (!Array.isArray(value)) {
+      throw new Error(`value must be of array type`);
+    }
+  },
   string: (value: string, field: types.StringField) => {
     if (typeof value !== 'string') {
       throw new Error(`value must be of string type`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rosen-bridge/config",
-  "version": "0.1.0",
+  "version": "0.2.1",
   "description": "a package to manage configs of rosen bridge projects",
   "repository": "git+https://github.com/rosen-bridge/utils.git",
   "license": "GPL-3.0",

package/tests/config.spec.ts

@@ -76,6 +76,44 @@ describe('ConfigValidator', () => {
           )
       ).toThrow();
     });
+
+    /**
+     * @target validateSchema should throw exception when array type doesn't
+     * have an item property
+     * @dependencies
+     * @scenario
+     * - create a new instance of Config which calls Config.validateSchema
+     * - check if any exception is thrown
+     * @expected
+     * - exception should be thrown
+     */
+    it(`should throw exception when array type doesn't have an item property`, async () => {
+      expect(
+        () =>
+          new ConfigValidator(
+            <ConfigSchema>testData.arrayTypeSchemaWithoutItems
+          )
+      ).toThrow();
+    });
+
+    /**
+     * @target validateSchema should throw exception when object type doesn't
+     * have a children property
+     * @dependencies
+     * @scenario
+     * - create a new instance of Config which calls Config.validateSchema
+     * - check if any exception is thrown
+     * @expected
+     * - exception should be thrown
+     */
+    it(`should throw exception when object type doesn't have a children property`, async () => {
+      expect(
+        () =>
+          new ConfigValidator(
+            <ConfigSchema>testData.objectTypeSchemaWithoutChildren
+          )
+      ).toThrow();
+    });
   });
 
   describe('validateConfig', () => {
@@ -679,6 +717,28 @@ describe('ConfigValidator', () => {
         testData.apiSchemaConfigPairWithStringNumber.config
       );
     });
+
+    /**
+     * @target validateConfig should throw exception when value doesn't match
+     * the schema array type
+     * @dependencies
+     * @scenario
+     * - call validateConfig with the config
+     * - check if any exception is thrown
+     * @expected
+     * - exception should be thrown
+     */
+    it(`should throw exception when value doesn't match the schema array type`, async () => {
+      const confValidator = new ConfigValidator(
+        <ConfigSchema>testData.arraySchemaConfigPairWrongValueType.schema
+      );
+
+      expect(() =>
+        confValidator.validateConfig(
+          testData.arraySchemaConfigPairWrongValueType.config
+        )
+      ).toThrow();
+    });
   });
 
   describe('valueAt', () => {
@@ -848,7 +908,7 @@ describe('ConfigValidator', () => {
 
       expect(() =>
         confValidator.validateAndWriteConfig(obj, config, 'local', 'json')
-      ).toThrow('value should be one of the choices');
+      ).toThrow();
 
       const savedObj = JSON.parse(
         fs.readFileSync(path.join(configDir, 'local.json'), 'utf-8')