@meltstudio/config-loader 1.0.0 → 1.0.1

package/README.md

@@ -1,19 +1,18 @@
 # Config Loader
 ## Project Description
 
-The Config Loader package is a powerful and user-friendly tool that simplifies the process of retrieving and collecting variables from one or multiple files for your project. It provides an efficient way to extract specific information from files and access those variables in your code. The resulting data is in JSON format, making it easy to work with in various applications.
+The Config Loader package is a powerful and user-friendly tool that simplifies the process of retrieving and collecting variables from one or multiple files for your project. It provides an efficient way to extract specific information from files and access those variables in your code. The result is a JSON object, making it easy to work with in various applications.
 
 ## Features
 - Retrieve and collect variables from one or multiple files in your project.
-- Yaml file support, support for JSON,YAML, XML files coming soon.
-- Allows you to specify filters to select only the desired variables.
-- Compatible with TypeScript environments, making it suitable for Node.js or browser-based projects.
+- YAML file support (support for other file types coming soon.)
+- Data can also be retrieved from CLI or environment variables .
+- Compatible with TypeScript/JavaScript environments, making it suitable for Node.js projects.
 
 ## Table of Contents
 
 - [Installation](#installation)
 - [Usage](#usage)
-- [Contributing](#contributing)
 - [License](#license)
 - [Acknowledgements](#acknowledgements)
 
@@ -43,6 +42,7 @@ import Settings, { option } from "@/src";
 const run = (): void => {
   const settings = new Settings(
     {
+      version: option.string({ required: true, cli: true }),
       website: {
         title: option.string({ required: true }),
         url: option.string({
@@ -66,12 +66,10 @@ const run = (): void => {
       }),
       features: option.array({
         required: true,
-        item: option.object({
-          item: {
-            cosa: option.string(),
-            test: option.bool(),
-          },
-        }),
+        item: {
+          name: option.string(),
+          enabled: option.bool(),
+        },
       }),
     },
     {
@@ -86,9 +84,40 @@ const run = (): void => {
 
 run();
 ```
+
+With a config.yaml file with the following contents:
+```yaml
+version: 1.0.0
+website:
+  title: My Website
+  description: A simple and elegant website
+  port: 3000
+  isProduction: false
+
+database:
+  host: localhost
+  port: 5432
+  credentials:
+    username: admin
+    password: secret
+
+socialMedia: [https://twitter.com/example, https://instagram.com/example]
+
+features:
+  - name: Store
+    enabled: true
+  - name: Admin
+    enabled: false
+
+apiKeys:
+  googleMaps: ${GOOGLE_MAPS_API_KEY}
+  sendGrid: ${SENDGRID_API_KEY}
+```
+
 The expected output would be:
 ```json
 {
+  "version": "1.0.0",
   "website": {
     "title": "My Website",
     "url": "www.mywebsite.dev",
@@ -126,7 +155,7 @@ You can try executing our example in your project by following these steps with
 yarn example:run
 ```
 ### Usage with CLI
-When using our package with cli, is important have the cli attribute must be set to true.
+When using our package with cli, it is important to have the cli attribute set to true.
 This will allow values to be sent when running the package from the command line.
 ```typescript
 import path from "path";
@@ -157,14 +186,19 @@ now for use it you need to send the property name on the command line with the n
 ```bash
 yarn example:run --version 2.0.0
 ```
+Having the following config.yaml file:
+```yaml
+version: 1.0.0
+```
 The expected output would be:
 ```json
 {
   "version": "2.0.0",
 }
 ```
+You can see that the CLI variable overrode the yaml file variable
 ### Usage with Environment Variables
-The Config Loader package allows you to harness the power of environment variables in your system configuration. You can specify variable names in your configuration and get them. to use this feature you need to set **env: true**
+The Config Loader package allows you to use environment variables in your system configuration. You can specify variable names in your configuration and get them. To use this feature you need to set **env: true**
 ```typescript
 import path from "path";
 
@@ -197,10 +231,19 @@ const run = (): void => {
 
 run();
 ```
+With the following config.yaml file:
+```yaml
+database:
+  host: localhost
+  port: 5432
+  credentials:
+    username: admin
+    password: IGNORED_PASSWORD
+```
 ```bash
 yarn example:run
 ```
-The expected output would be:
+If you have the environment variable `DB_PASSWORD=ENV_USED_PASSWORD`, the expected output would be:
 ```json
 {
   "database": {
@@ -208,29 +251,11 @@ The expected output would be:
     "port": 5432,
     "credentials": {
       "username": "admin",
-      "password": "MY_PASSWORD"
+      "password": "ENV_USED_PASSWORD"
     }
   }
 }
 ```
-
-## Contributing
-Explain how others can contribute to the project. Include guidelines for submitting issues, pull requests, or feature requests.
-
-1. Fork the repository
-2. Create a new branch
-3. Implement your changes
-4. Open a pull request
-
+You can notice that the environment variable overrode the value in the config.yaml file
 ## License
 This package is licensed under the Apache License 2.0. For more information, please see the [LICENSE](./LICENSE) file.
-
-## Acknowledgements
-
-🙌 We would like to express our gratitude to the following individuals and resources that have contributed to this project:
-
-- [Manuael Zapata](https://github.com/author1) 🚀: Co-creator and lead developer of the project.
-- [Pablo Piedrahita](https://github.com/author2) 👏: Co-creator and lead developer of the project.
-
-
-Thank you all for your valuable contributions and support! 🎉

package/dist/index.d.ts

@@ -0,0 +1,130 @@
+type SourceTypes = "file" | "env" | "args" | "default";
+declare class ConfigNode {
+    value: Value | ArrayValueContainer;
+    path: string;
+    source_type: SourceTypes;
+    file: string | null;
+    variable_name: string | null;
+    arg_name: string | null;
+    constructor(value: Value | ArrayValue, path: string, source_type: SourceTypes, file: string | null, variable_name: string | null, arg_name: string | null);
+}
+
+type NodeTree = {
+    [key: string]: NodeTree | ConfigNode;
+};
+type SettingsSources<T> = {
+    env: boolean;
+    args: boolean;
+    files?: string | string[] | false;
+    dir?: string | false;
+    defaults?: Partial<T>;
+};
+type OptionKind = "boolean" | "string" | "number" | "any" | "array" | "object";
+type Path = Array<string | number>;
+type ConfigFileStructure<T> = {
+    [key: string]: string | T | number | boolean | Array<T> | string[];
+};
+interface ConfigFileData extends ConfigFileStructure<ConfigFileData> {
+}
+type ArrayValue = Array<any>;
+declare class InvalidValue {
+}
+
+declare class ArrayValueContainer {
+    readonly val: ArrayValue;
+    readonly item: Node | OptionTypes;
+    constructor(item: Node | OptionTypes, val: ArrayValue);
+}
+
+type Value = boolean | string | number | object | InvalidValue;
+type DefaultValue = Value | (() => string) | (() => number);
+type RecursiveNode<T> = {
+    [key: string]: OptionBase | T;
+};
+interface Node extends RecursiveNode<Node> {
+}
+interface OptionClassParams {
+    kind: OptionKind;
+    required: boolean;
+    env: string | null;
+    cli: boolean;
+    help: string;
+    defaultValue?: DefaultValue;
+}
+declare class OptionBase {
+    readonly params: OptionClassParams;
+    constructor(params: OptionClassParams);
+    getValue<T>(sourceFile: string | string[], env: {
+        [key: string]: string | undefined;
+    }, args: {
+        [key: string]: string | boolean;
+    }, path: Path, defaultValues?: Partial<T>, objectFromArray?: {
+        value: ConfigFileData;
+        file: string;
+    }): ConfigNode | null;
+    protected checkNumberType(val: Value, pathStr: string, sourceOfVal: string): Value;
+    checkType(val: Value, path: Path, sourceOfVal: string): Value;
+    protected findInObject(obj: ConfigFileData, path: Path): Value | ArrayValue;
+    buildArrayOption(_val: string[] | ConfigFileData[]): ArrayValueContainer | InvalidValue;
+}
+
+interface ArrayOptionClassParams {
+    required: boolean;
+    defaultValue?: DefaultValue;
+    item: Node | OptionTypes;
+}
+declare class ArrayOption extends OptionBase {
+    item: Node | OptionTypes;
+    constructor(params: ArrayOptionClassParams);
+    buildArrayOption(val: string[] | ConfigFileData[]): ArrayValueContainer | InvalidValue;
+    checkType(val: Value, path: Path, sourceOfVal: string): Value;
+}
+
+declare class PrimitiveOption extends OptionBase {
+}
+
+type OptionTypes = PrimitiveOption | ArrayOption;
+
+declare class Settings<T> {
+    private readonly schema;
+    private readonly sources;
+    private sourceFile;
+    private argsData;
+    private envData;
+    private optionsTree;
+    private defaultData;
+    private program;
+    constructor(schema: Node, sources: SettingsSources<T>);
+    private validateFiles;
+    private load;
+    private traverseOptions;
+    private buildOption;
+    private getValidatedArray;
+    private processArrayWithSchema;
+    private setOption;
+    private addArg;
+    private getValuesFromTree;
+    get(): T;
+    getExtended(): NodeTree;
+}
+
+interface OptionPropsArgs {
+    required?: boolean;
+    env?: string | null;
+    cli?: boolean;
+    defaultValue?: DefaultValue;
+    help?: string;
+}
+interface ArrayOptionPropsArgs {
+    required?: boolean;
+    item: Node | OptionTypes;
+    defaultValue?: DefaultValue;
+}
+declare const option: {
+    string: (opts?: OptionPropsArgs) => PrimitiveOption;
+    number: (opts?: OptionPropsArgs) => PrimitiveOption;
+    bool: (opts?: OptionPropsArgs) => PrimitiveOption;
+    array: (opts: ArrayOptionPropsArgs) => ArrayOption;
+};
+
+export { Settings as default, option };

package/dist/index.js

@@ -0,0 +1,694 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  default: () => src_default,
+  option: () => option
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/types.ts
+var InvalidValue = class {
+};
+
+// src/option/arrayOption.ts
+var ArrayValueContainer = class {
+  val;
+  item;
+  constructor(item, val) {
+    this.val = val;
+    this.item = item;
+  }
+};
+var arrayOption_default = ArrayValueContainer;
+
+// src/option/base.ts
+var fs = __toESM(require("fs"));
+var import_js_yaml = __toESM(require("js-yaml"));
+
+// src/nodes/configNode.ts
+var ConfigNode = class {
+  value;
+  path;
+  source_type;
+  file;
+  variable_name;
+  arg_name;
+  constructor(value, path, source_type, file, variable_name, arg_name) {
+    this.value = value;
+    this.path = path;
+    this.source_type = source_type;
+    this.file = file;
+    this.variable_name = variable_name;
+    this.arg_name = arg_name;
+  }
+};
+var configNode_default = ConfigNode;
+
+// src/utils.ts
+function valueIsInvalid(val) {
+  return val instanceof InvalidValue || val === null || val === void 0;
+}
+
+// src/option/errors.ts
+var _OptionErrors = class {
+  static clearAll() {
+    _OptionErrors.errors = [];
+    _OptionErrors.warnings = [];
+  }
+};
+var OptionErrors = _OptionErrors;
+__publicField(OptionErrors, "errors", []);
+__publicField(OptionErrors, "warnings", []);
+
+// src/option/base.ts
+var OptionBase = class {
+  params;
+  constructor(params) {
+    this.params = params;
+  }
+  getValue(sourceFile, env, args, path, defaultValues, objectFromArray) {
+    const ident = path.join(".");
+    if (this.params.cli && args) {
+      if (ident in args) {
+        return new configNode_default(
+          this.checkType(args[ident], path, "args"),
+          ident,
+          "args",
+          null,
+          null,
+          ident
+        );
+      }
+    }
+    if (this.params.env && env) {
+      if (this.params.env in env) {
+        const val = env[this.params.env];
+        if (val) {
+          return new configNode_default(
+            this.checkType(val, path, "env"),
+            ident,
+            "env",
+            null,
+            this.params.env,
+            null
+          );
+        }
+      }
+    }
+    if (typeof sourceFile === "string") {
+      const data = import_js_yaml.default.load(
+        fs.readFileSync(sourceFile, "utf-8")
+      );
+      const val = this.findInObject(data || {}, path);
+      if (val instanceof arrayOption_default) {
+        return new configNode_default(
+          this.checkType(val, path, sourceFile),
+          ident,
+          "file",
+          sourceFile,
+          null,
+          null
+        );
+      }
+      if (!valueIsInvalid(val)) {
+        return new configNode_default(
+          this.checkType(val, path, sourceFile),
+          ident,
+          "file",
+          sourceFile,
+          null,
+          null
+        );
+      }
+    }
+    if (Array.isArray(sourceFile)) {
+      for (let index = 0; index < sourceFile.length; index += 1) {
+        const file = sourceFile[index];
+        const data = import_js_yaml.default.load(
+          fs.readFileSync(file, "utf-8")
+        );
+        const val = this.findInObject(data || {}, path);
+        if (val instanceof arrayOption_default) {
+          return new configNode_default(
+            this.checkType(val, path, file),
+            ident,
+            "file",
+            file,
+            null,
+            null
+          );
+        }
+        if (!valueIsInvalid(val)) {
+          return new configNode_default(
+            this.checkType(val, path, file),
+            ident,
+            "file",
+            file,
+            null,
+            null
+          );
+        }
+      }
+    }
+    if (objectFromArray) {
+      const val = this.findInObject(objectFromArray.value, path);
+      if (val instanceof arrayOption_default) {
+        return new configNode_default(
+          this.checkType(val, path, objectFromArray.file),
+          ident,
+          "file",
+          objectFromArray.file,
+          null,
+          null
+        );
+      }
+      if (!valueIsInvalid(val)) {
+        return new configNode_default(
+          this.checkType(val, path, objectFromArray.file),
+          ident,
+          "file",
+          objectFromArray.file,
+          null,
+          null
+        );
+      }
+    }
+    if (defaultValues) {
+      const val = this.findInObject(defaultValues, path);
+      if (val instanceof arrayOption_default) {
+        return new configNode_default(
+          this.checkType(val, path, "default"),
+          ident,
+          "default",
+          null,
+          null,
+          null
+        );
+      }
+      if (!valueIsInvalid(val)) {
+        return new configNode_default(
+          this.checkType(val, path, "default"),
+          ident,
+          "default",
+          null,
+          null,
+          null
+        );
+      }
+    }
+    if (this.params.defaultValue !== void 0) {
+      if (typeof this.params.defaultValue === "function") {
+        return new configNode_default(
+          // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+          this.checkType(this.params.defaultValue(), path, "default"),
+          ident,
+          "default",
+          null,
+          null,
+          null
+        );
+      }
+      return new configNode_default(
+        this.checkType(this.params.defaultValue, path, "default"),
+        ident,
+        "default",
+        null,
+        null,
+        null
+      );
+    }
+    if (this.params.required) {
+      OptionErrors.errors.push(`Required option '${ident}' not provided.`);
+    }
+    return null;
+  }
+  // eslint-disable-next-line class-methods-use-this
+  checkNumberType(val, pathStr, sourceOfVal) {
+    if (typeof val === "string") {
+      const parseVal = parseInt(val, 10);
+      if (Number.isNaN(parseVal)) {
+        OptionErrors.errors.push(
+          `Cannot convert value '${val}' for '${pathStr}' to number in ${sourceOfVal}.`
+        );
+        return new InvalidValue();
+      }
+      OptionErrors.warnings.push(
+        `The option ${pathStr} is stated as a number but is provided as a string`
+      );
+      return parseVal;
+    }
+    OptionErrors.errors.push(`Invalid state. Invalid kind in ${sourceOfVal}`);
+    return new InvalidValue();
+  }
+  checkType(val, path, sourceOfVal) {
+    const ident = path.join(".");
+    if (valueIsInvalid(val)) {
+      OptionErrors.errors.push(`Invalid state. Invalid kind in ${sourceOfVal}`);
+      return val;
+    }
+    if (typeof val === this.params.kind) {
+      return val;
+    }
+    if (this.params.kind === "string") {
+      if (typeof val === "number") {
+        OptionErrors.warnings.push(
+          `The option ${ident} is stated as a string but is provided as a number`
+        );
+        return val.toString();
+      }
+      OptionErrors.errors.push(
+        `Cannot convert value '${val.toString()}' for '${ident}' to string in ${sourceOfVal}.`
+      );
+      return new InvalidValue();
+    }
+    if (this.params.kind === "boolean") {
+      if (typeof val !== "boolean" && typeof val !== "object") {
+        if ([1, "1", "true"].includes(val)) {
+          return true;
+        }
+        if ([0, "0", "false"].includes(val)) {
+          return false;
+        }
+      }
+      OptionErrors.errors.push(
+        `Cannot convert value '${val.toString()}' for '${ident}' to boolean in ${sourceOfVal}.`
+      );
+      return new InvalidValue();
+    }
+    if (this.params.kind === "number") {
+      return this.checkNumberType(val, ident, sourceOfVal);
+    }
+    if (this.params.kind === "any") {
+      return val;
+    }
+    OptionErrors.errors.push(`Invalid state. Invalid kind in ${sourceOfVal}`);
+    throw new Error(
+      "Invalid kind. Must be 'string', 'number', 'boolean', 'array' or 'any'"
+    );
+  }
+  findInObject(obj, path) {
+    if (path.length > 1) {
+      const [child, ...rest] = path;
+      const val = obj[child];
+      if (typeof val === "string") {
+        OptionErrors.errors.push(`Cant get path from string value '${val}'`);
+        return new InvalidValue();
+      }
+      if (typeof val === "number") {
+        OptionErrors.errors.push(`Cant get path from number value '${val}'`);
+        return new InvalidValue();
+      }
+      if (typeof val === "boolean") {
+        OptionErrors.errors.push(
+          `Cant get path from boolean value '${val.toString()}'`
+        );
+        return new InvalidValue();
+      }
+      if (Array.isArray(val)) {
+        OptionErrors.errors.push(
+          `Cant get path from array value '${val.toString()}'`
+        );
+        return new InvalidValue();
+      }
+      if (val == null) {
+        return new InvalidValue();
+      }
+      return this.findInObject(val, rest);
+    }
+    if (path.length === 1) {
+      const val = obj[path[0]];
+      if (!Array.isArray(val) && typeof val === "object" && val || typeof val === "string" || typeof val === "number" || typeof val === "boolean" || typeof val === "undefined") {
+        return val;
+      }
+      if (Array.isArray(val)) {
+        return this.buildArrayOption(val);
+      }
+      OptionErrors.errors.push(
+        `Invalid path '${path.join(".")}': ${typeof val}`
+      );
+      return new InvalidValue();
+    }
+    OptionErrors.errors.push(`Invalid path '${path.join()}'`);
+    return new InvalidValue();
+  }
+  // eslint-disable-next-line class-methods-use-this
+  buildArrayOption(_val) {
+    return new InvalidValue();
+  }
+};
+
+// src/option/array.ts
+var ArrayOption = class extends OptionBase {
+  item;
+  constructor(params) {
+    super({
+      kind: "array",
+      env: null,
+      cli: false,
+      help: "",
+      ...params
+    });
+    this.item = params.item;
+  }
+  buildArrayOption(val) {
+    if (this.item === null) {
+      OptionErrors.errors.push(`Array item cannot be null`);
+      return new InvalidValue();
+    }
+    return new arrayOption_default(this.item, val);
+  }
+  // eslint-disable-next-line class-methods-use-this
+  checkType(val, path, sourceOfVal) {
+    if (val instanceof arrayOption_default) {
+      val.val.forEach((v, i) => {
+        if (this.item instanceof OptionBase) {
+          this.item.checkType(v, [...path, i], sourceOfVal);
+        }
+      });
+      return val;
+    }
+    OptionErrors.errors.push(`Invalid state. Invalid kind in ${sourceOfVal}`);
+    return new InvalidValue();
+  }
+};
+
+// src/option/primitive.ts
+var PrimitiveOption = class extends OptionBase {
+};
+
+// src/settings.ts
+var import_commander = require("commander");
+var fs2 = __toESM(require("fs"));
+
+// src/nodes/configNodeArray.ts
+var ConfigNodeArray = class {
+  arrayValues;
+  constructor(arrayValues) {
+    this.arrayValues = arrayValues;
+  }
+};
+var configNodeArray_default = ConfigNodeArray;
+
+// src/settings.ts
+var Settings = class {
+  schema;
+  sources;
+  sourceFile = [];
+  argsData = {};
+  envData = {};
+  optionsTree = {};
+  defaultData = {};
+  program;
+  constructor(schema, sources) {
+    this.schema = schema;
+    this.sources = sources;
+    this.program = new import_commander.Command();
+    this.load();
+  }
+  validateFiles() {
+    const { files, dir } = this.sources;
+    if (files && dir)
+      throw new Error("Dir and files are specified, choose one");
+    if (files) {
+      if (Array.isArray(files)) {
+        files.forEach((file) => {
+          if (!fs2.existsSync(file)) {
+            throw new Error(`Invalid config file '${file}'`);
+          } else {
+            if (!Array.isArray(this.sourceFile)) {
+              this.sourceFile = [];
+            }
+            this.sourceFile.push(file);
+          }
+        });
+      } else {
+        if (!fs2.existsSync(files)) {
+          throw new Error(`Invalid config file '${files}'`);
+        }
+        this.sourceFile = files;
+      }
+    }
+    if (dir) {
+      if (!(fs2.existsSync(dir) && fs2.lstatSync(dir).isDirectory())) {
+        throw new Error(`'${dir}' not exists or is not a dir`);
+      }
+      const filesInDirectory = fs2.readdirSync(dir);
+      if (filesInDirectory.length === 0) {
+        throw new Error(`Directory '${dir}' is empty`);
+      }
+      filesInDirectory.forEach((file) => {
+        if (!Array.isArray(this.sourceFile)) {
+          this.sourceFile = [];
+        }
+        this.sourceFile.unshift(`${dir}/${file}`);
+      });
+    }
+  }
+  load() {
+    this.validateFiles();
+    if (this.sources.env) {
+      this.envData = process.env;
+    }
+    if (this.sources.args) {
+      this.traverseOptions(this.schema, [], this.addArg.bind(this));
+      this.program.parse(process.argv);
+      this.argsData = this.program.opts();
+    }
+    if (this.sources.defaults) {
+      this.defaultData = this.sources.defaults;
+    }
+    this.traverseOptions(
+      this.schema,
+      [],
+      this.buildOption.bind(this, this.optionsTree, {
+        sourceFile: this.sourceFile,
+        envData: this.envData,
+        argsData: this.argsData,
+        defaultValue: this.defaultData
+      })
+    );
+    if (OptionErrors.warnings.length > 0) {
+      for (let index = 0; index < OptionErrors.warnings.length; index += 1) {
+        console.warn(`[Warning]: ${OptionErrors.warnings[index]}`);
+      }
+    }
+    if (OptionErrors.errors.length > 0) {
+      for (let index = 0; index < OptionErrors.errors.length; index += 1) {
+        console.error(`[Error]: ${OptionErrors.errors[index]}`);
+      }
+      process.exit(1);
+    }
+  }
+  traverseOptions(node, path, callback) {
+    if (node instanceof OptionBase) {
+      callback(node, path);
+    } else {
+      Object.keys(node).forEach((key) => {
+        const val = node[key];
+        this.traverseOptions(val, [...path, key], callback);
+      });
+    }
+  }
+  buildOption(result, configData, node, path) {
+    const { sourceFile, envData, argsData, defaultValue, objectFromArray } = configData;
+    const value = node.getValue(
+      sourceFile,
+      envData,
+      argsData,
+      path,
+      defaultValue,
+      objectFromArray
+    );
+    if (value === null) {
+    } else {
+      this.setOption(result, path, value);
+    }
+  }
+  getValidatedArray(item, values, file) {
+    if (item instanceof PrimitiveOption) {
+      if (item.params.kind === "string") {
+        return values.map((v) => v);
+      }
+      if (item.params.kind === "number") {
+        return values.map((v) => parseInt(v, 10));
+      }
+      if (item.params.kind === "boolean") {
+        return values.map((v) => {
+          if (v === "true")
+            return true;
+          if (v === "1")
+            return true;
+          if (v === 1)
+            return true;
+          if (v === "false")
+            return false;
+          if (v === "0")
+            return false;
+          if (v === 0)
+            return false;
+          return v;
+        });
+      }
+    }
+    const arrayValues = values.map(
+      (v) => (
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+        this.processArrayWithSchema(item, v, file)
+      )
+    );
+    return new configNodeArray_default(arrayValues);
+  }
+  processArrayWithSchema(item, v, file) {
+    const result = {};
+    this.traverseOptions(
+      item,
+      [],
+      this.buildOption.bind(this, result, {
+        objectFromArray: {
+          // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+          value: v,
+          file
+        }
+      })
+    );
+    return result;
+  }
+  setOption(options, path, node) {
+    if (path.length > 1) {
+      const [child, ...rest] = path;
+      if (!options[child]) {
+        options[child] = {};
+      }
+      this.setOption(options[child], rest, node);
+    } else if (path.length === 1) {
+      const [child] = path;
+      if (node != null) {
+        if (node.value instanceof arrayOption_default) {
+          options[child] = node;
+          options[child].value = this.getValidatedArray(
+            node.value.item,
+            node.value.val,
+            node.file || node.variable_name || node.arg_name || ""
+          );
+        } else {
+          options[child] = node;
+        }
+      }
+    } else {
+      throw new Error(
+        `Invalid path '${node.path}' getting from '${node.arg_name || node.file || node.variable_name || ""}' in ' ${node.source_type}`
+      );
+    }
+  }
+  addArg(node, path = []) {
+    if (node.params.cli) {
+      const ident = path.join(".");
+      this.program.option(`--${ident} <value>`, node.params.help);
+    }
+  }
+  getValuesFromTree(node) {
+    if (node instanceof configNode_default) {
+      if (node.value instanceof configNodeArray_default) {
+        return node.value.arrayValues.map(this.getValuesFromTree.bind(this));
+      }
+      return node.value;
+    }
+    return Object.entries(node).reduce(
+      (acc, item) => {
+        const [key, value] = item;
+        acc[key] = this.getValuesFromTree(value);
+        return acc;
+      },
+      {}
+    );
+  }
+  get() {
+    return this.getValuesFromTree(this.optionsTree);
+  }
+  getExtended() {
+    return this.optionsTree;
+  }
+};
+var settings_default = Settings;
+
+// src/index.ts
+var src_default = settings_default;
+var DEFAULTS = {
+  required: false,
+  env: null,
+  cli: false,
+  help: ""
+  // properties: {},
+};
+var string = (opts) => {
+  return new PrimitiveOption({
+    kind: "string",
+    ...DEFAULTS,
+    ...opts
+  });
+};
+var number = (opts) => {
+  return new PrimitiveOption({
+    kind: "number",
+    ...DEFAULTS,
+    ...opts
+  });
+};
+var bool = (opts) => {
+  return new PrimitiveOption({
+    kind: "boolean",
+    ...DEFAULTS,
+    ...opts
+  });
+};
+var array = (opts) => {
+  return new ArrayOption({
+    ...DEFAULTS,
+    ...opts
+  });
+};
+var option = {
+  string,
+  number,
+  bool,
+  // object,
+  array
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  option
+});

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "@meltstudio/config-loader",
-  "version": "1.0.0",
+  "version": "1.0.1",
   "description": "Melt Studio's tool for loading configurations into a Node.js application.",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
   "repository": "https://github.com/MeltStudio/config-loader",
   "author": "MeltStudio <dev@meltstudio.co>",
-  "license": "MIT",
+  "license": "Apache-2.0",
   "keywords": [
     "configuration",
     "config",
@@ -20,12 +20,12 @@
     "README.md"
   ],
   "scripts": {
-    "build": "rimraf ./dist && tsup src/index.ts --dts --config tsconfig.build.json && yarn replace-tspaths",
+    "build": "rimraf ./dist && tsup src/index.ts --dts --config tsconfig.build.json",
     "lint": "eslint --ext .ts --max-warnings=0 --fix .",
     "type-check": "tsc --noEmit",
     "test": "jest --verbose",
-    "replace-tspaths": "./scripts/replace-tspaths/index.mjs",
-    "example:run": "ts-node -r tsconfig-paths/register ./example/index.ts"
+    "example:run": "ts-node -r tsconfig-paths/register ./example/index.ts",
+    "prepare": "husky install"
   },
   "dependencies": {
     "@types/js-yaml": "^4.0.5",