@cenk1cenk2/oclif-common 3.7.2 → 3.8.0

package/dist/hooks/index.js

@@ -33,14 +33,14 @@ __export(hooks_exports, {
 module.exports = __toCommonJS(hooks_exports);
 
 // src/hooks/not-found.hook.ts
-var import_core = require("@oclif/core");
+var import_core3 = require("@oclif/core");
 
 // src/utils/logger/listr-logger.ts
 var import_listr22 = require("listr2");
 
 // src/utils/logger/logger.ts
 var import_listr2 = require("listr2");
-var import_os = require("os");
+var import_os2 = require("os");
 var import_winston = __toESM(require("winston"));
 
 // src/utils/logger/logger.constants.ts
@@ -57,10 +57,511 @@ var LogLevels = /* @__PURE__ */ ((LogLevels2) => {
   return LogLevels2;
 })(LogLevels || {});
 
+// src/lib/config/config.service.ts
+var import_object_path_immutable = __toESM(require("object-path-immutable"));
+var import_path2 = require("path");
+
+// src/interfaces/oclif.interface.ts
+var import_core = require("@oclif/core");
+
+// src/constants/global-flags.constants.ts
+var CLI_FLAGS = {
+  ["log-level"]: import_core.Flags.enum({
+    default: "INFO" /* INFO */,
+    env: "LOG_LEVEL",
+    description: "Set the log level of the application.",
+    options: [...Object.values(LogLevels), ...Object.values(LogLevels).map((level) => level.toLowerCase())],
+    helpGroup: "CLI" /* CLI */,
+    parse: async (input) => input?.toUpperCase()
+  }),
+  ci: import_core.Flags.boolean({
+    default: false,
+    env: "CI",
+    description: "Instruct whether this is running the CI/CD configuration.",
+    helpGroup: "CLI" /* CLI */
+  }),
+  json: import_core.Flags.boolean({
+    default: false,
+    env: "JSON",
+    description: "Put the CLI to respond in JSON.",
+    helpGroup: "CLI" /* CLI */
+  })
+};
+
+// src/lib/parser/env-parser.service.ts
+var import_os = require("os");
+var _EnvironmentVariableParser = class {
+  constructor() {
+    this.LINE = /(?:^|^)\s*(?:export\s+)?([\w.-]+)(?:\s*=\s*?|:\s+?)(\s*'(?:\\'|[^'])*'|\s*"(?:\\"|[^"])*"|\s*`(?:\\`|[^`])*`|[^#\r\n]+)?\s*(?:#.*)?(?:$|$)/gm;
+    if (_EnvironmentVariableParser.instance) {
+      return _EnvironmentVariableParser.instance;
+    }
+    _EnvironmentVariableParser.instance = this;
+    this.logger = new Logger(this.constructor.name);
+    this.logger.trace("Created a new instance.");
+  }
+  parse(data) {
+    try {
+      return data.toString().split(import_os.EOL).reduce((o, line) => {
+        const match = this.LINE.exec(line);
+        const key = match[1];
+        const value = match[2] ?? "";
+        return {
+          ...o,
+          [key]: value
+        };
+      }, {});
+    } catch (e) {
+      this.logger.trace("Error during parsing environment file: %s", e.message);
+      throw e;
+    }
+  }
+  stringify(data) {
+    return Object.entries(data).map(([k, v]) => `${k}=${v}`).join(import_os.EOL) + import_os.EOL;
+  }
+};
+var EnvironmentVariableParser = _EnvironmentVariableParser;
+__name(EnvironmentVariableParser, "EnvironmentVariableParser");
+EnvironmentVariableParser.extensions = ["env"];
+
+// src/lib/parser/json-parser.service.ts
+var _JsonParser = class {
+  constructor() {
+    if (_JsonParser.instance) {
+      return _JsonParser.instance;
+    }
+    _JsonParser.instance = this;
+    this.logger = new Logger(this.constructor.name);
+    this.logger.trace("Created a new instance.");
+  }
+  parse(data) {
+    try {
+      return JSON.parse(data.toString());
+    } catch (e) {
+      this.logger.trace("Error during parsing JSON file: %s", e.message);
+      throw e;
+    }
+  }
+  stringify(data) {
+    return JSON.stringify(data, null, 2);
+  }
+};
+var JsonParser = _JsonParser;
+__name(JsonParser, "JsonParser");
+JsonParser.extensions = ["json"];
+
+// src/lib/parser/yaml-parser.service.ts
+var import_yaml = require("yaml");
+var _YamlParser = class {
+  constructor() {
+    if (_YamlParser.instance) {
+      return _YamlParser.instance;
+    }
+    _YamlParser.instance = this;
+    this.logger = new Logger(this.constructor.name);
+    this.logger.trace("Created a new instance.");
+  }
+  parse(data) {
+    try {
+      return (0, import_yaml.parse)(data.toString());
+    } catch (e) {
+      this.logger.trace("Error during parsing YAML file: %s", e.message);
+      throw e;
+    }
+  }
+  stringify(data) {
+    return (0, import_yaml.stringify)(data, { prettyErrors: true });
+  }
+};
+var YamlParser = _YamlParser;
+__name(YamlParser, "YamlParser");
+YamlParser.extensions = ["yaml", "yml"];
+
+// src/lib/fs/filesystem.service.ts
+var import_fs_extra = __toESM(require("fs-extra"));
+var import_path = require("path");
+var FileSystemService = class {
+  constructor() {
+    if (FileSystemService.instance) {
+      return FileSystemService.instance;
+    } else {
+      FileSystemService.instance = this;
+      this.logger = new Logger(this.constructor.name);
+      this.logger.trace("Created a new instance.");
+    }
+  }
+  exists(path) {
+    return import_fs_extra.default.existsSync(path);
+  }
+  stats(path) {
+    return import_fs_extra.default.statSync(path, { throwIfNoEntry: true });
+  }
+  dirname(path) {
+    return (0, import_path.dirname)(path);
+  }
+  extname(path) {
+    return (0, import_path.extname)(path);
+  }
+  async read(file) {
+    try {
+      const raw = await import_fs_extra.default.readFile(file, "utf-8");
+      return raw;
+    } catch (e) {
+      throw new Error(`Error while reading file from "${file}": ${e.message}`);
+    }
+  }
+  readSync(file) {
+    try {
+      const raw = import_fs_extra.default.readFileSync(file, "utf-8");
+      return raw;
+    } catch (e) {
+      throw new Error(`Error while reading file from "${file}": ${e.message}`);
+    }
+  }
+  async write(file, data, options = {}) {
+    try {
+      await import_fs_extra.default.writeFile(file, data, { encoding: "utf-8", ...options });
+    } catch (e) {
+      throw new Error(`Error while writing file to "${file}": ${e.message}`);
+    }
+  }
+  writeSync(file, data, options = {}) {
+    try {
+      import_fs_extra.default.writeFileSync(file, data, { encoding: "utf-8", ...options });
+    } catch (e) {
+      throw new Error(`Error while writing file to "${file}": ${e.message}`);
+    }
+  }
+  async append(file, data, options) {
+    try {
+      await import_fs_extra.default.appendFile(file, data, options);
+    } catch (e) {
+      throw new Error(`Error while appending to file  "${file}": ${e.message}`);
+    }
+  }
+  appendSync(file, data) {
+    try {
+      import_fs_extra.default.appendFileSync(file, data);
+    } catch (e) {
+      throw new Error(`Error while appending to file  "${file}": ${e.message}`);
+    }
+  }
+  async remove(file, options) {
+    try {
+      await import_fs_extra.default.rm(file, options);
+    } catch (e) {
+      throw new Error(`Error while deleting the file "${file}": ${e.message}`);
+    }
+  }
+  removeSync(file, options) {
+    try {
+      import_fs_extra.default.rmSync(file, options);
+    } catch (e) {
+      throw new Error(`Error while deleting the file "${file}": ${e.message}`);
+    }
+  }
+  async emptyDir(directory) {
+    try {
+      await import_fs_extra.default.emptyDir(directory);
+    } catch (e) {
+      throw new Error(`Error while emptying the directory "${directory}": ${e.message}`);
+    }
+  }
+  emptyDirSync(directory) {
+    try {
+      import_fs_extra.default.emptyDirSync(directory);
+    } catch (e) {
+      throw new Error(`Error while emptying the directory "${directory}": ${e.message}`);
+    }
+  }
+  async removeDir(directory) {
+    try {
+      await import_fs_extra.default.rmdir(directory);
+    } catch (e) {
+      throw new Error(`Error while removing the directory "${directory}": ${e.message}`);
+    }
+  }
+  removeDirSync(directory) {
+    try {
+      import_fs_extra.default.rmdirSync(directory);
+    } catch (e) {
+      throw new Error(`Error while removing the directory "${directory}": ${e.message}`);
+    }
+  }
+  async mkdir(directory) {
+    try {
+      await import_fs_extra.default.mkdirp(directory);
+    } catch (e) {
+      throw new Error(`Error while creating the directory "${directory}": ${e.message}`);
+    }
+  }
+  mkdirSync(directory) {
+    try {
+      import_fs_extra.default.mkdirSync(directory);
+    } catch (e) {
+      throw new Error(`Error while creating the directory "${directory}": ${e.message}`);
+    }
+  }
+};
+__name(FileSystemService, "FileSystemService");
+
+// src/lib/parser/parser.service.ts
+var ParserService = class {
+  constructor(parsers) {
+    this.parsers = [YamlParser, JsonParser, EnvironmentVariableParser];
+    if (ParserService.instance) {
+      return ParserService.instance;
+    } else {
+      if (parsers) {
+        this.parsers = parsers;
+      }
+      this.logger = new Logger(this.constructor.name);
+      this.fs = new FileSystemService();
+      ParserService.instance = this;
+      this.logger.trace("Created a new instance.");
+    }
+  }
+  getParser(file) {
+    const ext = (file.includes(".") ? this.fs.extname(file) : file).replace(/^\./, "");
+    const Parser = this.parsers.find((parser) => parser.extensions.includes(ext));
+    if (!Parser) {
+      throw new Error(`Parser for the extension is not configured: ${ext}`);
+    }
+    return new Parser();
+  }
+  setParsers(...parsers) {
+    this.parsers = parsers;
+    this.logger.trace(
+      "Set parsers: %s",
+      this.parsers.map((p) => p.name)
+    );
+  }
+  addParsers(...parsers) {
+    this.parsers.push(...parsers);
+    this.logger.trace(
+      "Added parser, current parsers: %s",
+      this.parsers.map((p) => p.name)
+    );
+  }
+  async read(file) {
+    return this.parse(file, await this.fs.read(file));
+  }
+  async write(file, data) {
+    return this.fs.write(file, await this.stringify(file, data));
+  }
+  parse(file, data) {
+    const parser = this.getParser(file);
+    this.logger.trace("Parsing file: %s -> %s", file, parser.constructor.name);
+    return parser.parse(data);
+  }
+  stringify(file, data) {
+    const parser = this.getParser(file);
+    this.logger.trace("Stringifying file: %s -> %s", file, parser.constructor.name);
+    return parser.stringify(data);
+  }
+};
+__name(ParserService, "ParserService");
+
 // src/utils/color.ts
 var colorette = __toESM(require("colorette"));
 var color = colorette.createColors({ useColor: true });
 
+// src/utils/environment.ts
+function isVerbose(logLevel) {
+  return logLevel === "VERBOSE" /* VERBOSE */;
+}
+__name(isVerbose, "isVerbose");
+function isDebug(logLevel) {
+  return ["DEBUG" /* DEBUG */, "TRACE" /* TRACE */].includes(logLevel);
+}
+__name(isDebug, "isDebug");
+function isSilent(logLevel) {
+  return logLevel === "SILENT" /* SILENT */;
+}
+__name(isSilent, "isSilent");
+
+// src/utils/merge.ts
+var import_deepmerge = __toESM(require("deepmerge"));
+function merge(strategy, ...source) {
+  return import_deepmerge.default.all(source, {
+    arrayMerge: strategy === "EXTEND" /* EXTEND */ ? (dest, src) => [...dest, ...src].filter(uniqueFilter) : (_, src) => src
+  });
+}
+__name(merge, "merge");
+function uniqueFilter(value, index, self) {
+  return self.indexOf(value) === index;
+}
+__name(uniqueFilter, "uniqueFilter");
+
+// src/utils/index.ts
+var import_core2 = require("@oclif/core");
+
+// src/lib/config/config.service.ts
+var ConfigService = class {
+  constructor(oclif, command, config) {
+    this.oclif = oclif;
+    this.command = command;
+    if (ConfigService.instance) {
+      Object.assign(ConfigService.instance, config);
+      return ConfigService.instance;
+    } else {
+      ConfigService.instance = this;
+    }
+    this.root = this.oclif.root;
+    this.defaults = (0, import_path2.join)(this.oclif.root, "config" /* CONFIG_SERVICE_DEFAULTS_DIR */);
+    this.logger = new Logger(this.constructor.name, { level: config.logLevel });
+    this.parser = new ParserService();
+    Object.assign(ConfigService.instance, config);
+    this.recalculate();
+    this.logger.trace("Created a new instance.");
+  }
+  async read(path) {
+    const config = await this.parser.read(path);
+    this.logger.trace("Read config from: %s", path);
+    return config;
+  }
+  async extend(paths, strategy = "OVERWRITE" /* OVERWRITE */) {
+    this.logger.trace("Will generate config from: %o with %s", paths, strategy);
+    const configs = (await Promise.all(
+      paths.map(async (path) => {
+        try {
+          const config = typeof path === "string" ? await this.parser.read(path) : path;
+          this.logger.trace("Extending config from: %s", path);
+          return config;
+        } catch (e) {
+          this.logger.trace("Failed to extend config from: %s", e.message);
+        }
+      })
+    )).filter(Boolean);
+    return this.merge(configs, strategy);
+  }
+  merge(configs, strategy = "OVERWRITE" /* OVERWRITE */) {
+    if (configs.length === 0) {
+      throw new Error("Nothing to merge, configuration files are empty.");
+    }
+    return merge(strategy, ...configs);
+  }
+  async env(definition, config) {
+    const env = typeof definition === "string" ? await this.parser.read(definition) : definition;
+    this.logger.trace("Environment variable extensions read: %o", definition);
+    const iter = /* @__PURE__ */ __name(async (obj, parent) => {
+      const data = await Promise.all(
+        Object.entries(obj).map(async ([key, value]) => {
+          const location = [...parent ?? [], key];
+          if (typeof value === "string") {
+            return [{ key: location, env: value }];
+          } else if (typeof value === "object") {
+            let extensions;
+            if ("__element" /* ELEMENT */ in value) {
+              extensions = await iter(value["__element" /* ELEMENT */], [...location, "__element" /* ELEMENT */]);
+              this.logger.trace("Expanding location to elements: %s -> %s", location, extensions.map((extension) => extension.key.join(".")).join(", "));
+            }
+            if ("__name" /* NAME */ in value && "__format" /* PARSER */ in value) {
+              const variable = [
+                {
+                  key: location,
+                  env: value["__name" /* NAME */],
+                  parser: value["__format" /* PARSER */],
+                  extensions
+                }
+              ];
+              return variable;
+            } else {
+              return iter(value, location);
+            }
+          }
+        })
+      );
+      return data.flatMap((d) => d).filter(Boolean);
+    }, "iter");
+    const parsed = await iter(env);
+    const cb = /* @__PURE__ */ __name((config2, variable, data) => {
+      if (variable.parser) {
+        try {
+          data = this.parser.parse(variable.parser, data);
+        } catch (e) {
+          this.logger.trace("Can not parse environment environment variable for config: %s -> %s with %s", variable.key.join("."), variable.env, variable.parser);
+          throw e;
+        }
+      }
+      this.logger.trace("Overwriting config with environment variable: %s -> %s", variable.key.join("."), variable.env);
+      return import_object_path_immutable.default.set(config2, variable.key, data);
+    }, "cb");
+    parsed.forEach((variable) => {
+      let data;
+      data = process.env[variable.env];
+      if (data) {
+        config = cb(config, variable, data);
+      }
+      if (variable.extensions && variable.extensions.length > 0) {
+        const timeout = 6e4;
+        const startedAt = Date.now();
+        for (let i = 0; i < Infinity; i++) {
+          if (Date.now() - startedAt > timeout) {
+            throw new Error(`Timed-out in ${timeout}ms while looking for element environment variables.`);
+          }
+          const extensions = variable.extensions.map((extension) => {
+            const clone = JSON.parse(JSON.stringify(extension));
+            clone.env = clone.env.replace("${i}" /* ELEMENT_REPLACER */, i.toString());
+            clone.key[clone.key.findIndex((value) => value === "__element" /* ELEMENT */)] = i.toString();
+            data = process.env[clone.env];
+            if (!data) {
+              this.logger.trace("No extension for environment variable: %s -> %s", clone.key.join("."), clone.env);
+              return;
+            }
+            config = cb(config, clone, data);
+            return true;
+          }).filter(Boolean);
+          if (extensions.length === 0) {
+            this.logger.trace("No more extensions for environment variables: %s -> %d", variable.key.join("."), i);
+            break;
+          }
+        }
+      }
+    });
+    return config;
+  }
+  async write(path, data) {
+    return this.parser.write(path, data);
+  }
+  recalculate() {
+    this.isVerbose = isVerbose(this.logLevel);
+    this.isDebug = isDebug(this.logLevel);
+    this.isSilent = isSilent(this.logLevel);
+  }
+};
+__name(ConfigService, "ConfigService");
+
+// src/lib/locker/locker.service.ts
+var import_object_path_immutable2 = __toESM(require("object-path-immutable"));
+
+// src/lib/store/store.service.ts
+var StoreService = class {
+  constructor() {
+    this.store = {};
+    if (StoreService.instance) {
+      return StoreService.instance;
+    } else {
+      StoreService.instance = this;
+    }
+  }
+  has(key) {
+    return !!this.store[key];
+  }
+  get(key) {
+    return this.store[key];
+  }
+  set(key, data) {
+    this.store[key] = data;
+    return data;
+  }
+};
+__name(StoreService, "StoreService");
+
+// src/lib/validator/validator.service.ts
+var import_class_transformer = require("class-transformer");
+var import_class_validator = require("class-validator");
+
 // src/utils/logger/logger.ts
 var Logger = class {
   constructor(context, options) {
@@ -75,8 +576,9 @@ var Logger = class {
     };
     if (Logger.instance) {
       this.logger = Logger.instance;
-    } else {
+    } else if (context === ConfigService.name) {
       this.logger = this.initiateLogger();
+      this.trace("Logger singleton initiated from context: %s", context);
       Logger.instance = this.logger;
     }
   }
@@ -119,7 +621,7 @@ var Logger = class {
   initiateLogger() {
     const logFormat = import_winston.format.printf(({ level, message, context, status }) => {
       let multiLineMessage;
-      multiLineMessage = message.split(import_os.EOL);
+      multiLineMessage = message.split(import_os2.EOL);
       multiLineMessage = multiLineMessage.filter((msg) => msg.trim() !== "").filter(Boolean);
       multiLineMessage = multiLineMessage.map((msg) => {
         return this.logColoring({
@@ -129,7 +631,7 @@ var Logger = class {
           status
         });
       });
-      return multiLineMessage.join(import_os.EOL);
+      return multiLineMessage.join(import_os2.EOL);
     });
     const logger = import_winston.default.createLogger({
       level: this.options.level,
@@ -151,6 +653,11 @@ var Logger = class {
     return logger;
   }
   parseMessage(level, data, args, format2) {
+    if (!this.logger && !Logger.instance) {
+      return;
+    } else if (Logger.instance) {
+      this.logger = Logger.instance;
+    }
     this.logger.log(level, data.toString(), ...args ?? [], { context: this.context, ...format2 ?? {} });
   }
   logColoring({ level, message, context, status }) {
@@ -228,7 +735,7 @@ var notFoundHook = /* @__PURE__ */ __name(async (opts) => {
   const logger = new Logger(opts.config.name);
   logger.fatal("Command not found. Take a look at help. You can also use --[h]elp flag for subcommands.", { custom: opts.config.name });
   logger.direct("");
-  const help = new import_core.Help(opts.config);
+  const help = new import_core3.Help(opts.config);
   await help.showHelp(["--all"]);
   process.exit(127);
 }, "notFoundHook");
@@ -239,130 +746,6 @@ var updateNotifierHook = /* @__PURE__ */ __name(async (opts) => {
   (0, import_update_notifier.default)({ pkg: { name: opts.config.name, version: opts.config.version } }).notify({ isGlobal: true });
 }, "updateNotifierHook");
 
-// src/lib/config/config.service.ts
-var import_object_path_immutable = __toESM(require("object-path-immutable"));
-var import_path2 = require("path");
-
-// src/interfaces/oclif.interface.ts
-var import_core2 = require("@oclif/core");
-
-// src/constants/global-flags.constants.ts
-var CLI_FLAGS = {
-  ["log-level"]: import_core2.Flags.enum({
-    default: "INFO" /* INFO */,
-    env: "LOG_LEVEL",
-    description: "Set the log level of the application.",
-    options: [...Object.values(LogLevels), ...Object.values(LogLevels).map((level) => level.toLowerCase())],
-    helpGroup: "CLI" /* CLI */,
-    parse: async (input) => input?.toUpperCase()
-  }),
-  ci: import_core2.Flags.boolean({
-    default: false,
-    env: "CI",
-    description: "Instruct whether this is running the CI/CD configuration.",
-    helpGroup: "CLI" /* CLI */
-  }),
-  json: import_core2.Flags.boolean({
-    default: false,
-    env: "JSON",
-    description: "Put the CLI to respond in JSON.",
-    helpGroup: "CLI" /* CLI */
-  })
-};
-
-// src/lib/parser/json-parser.service.ts
-var _JsonParser = class {
-  constructor() {
-    if (_JsonParser.instance) {
-      return _JsonParser.instance;
-    }
-    _JsonParser.instance = this;
-    this.logger = new Logger(this.constructor.name);
-    this.logger.trace("Created a new instance.");
-  }
-  parse(data) {
-    try {
-      return JSON.parse(data.toString());
-    } catch (e) {
-      this.logger.trace("Error during parsing JSON file: %s", e.message);
-      throw e;
-    }
-  }
-  stringify(data) {
-    return JSON.stringify(data, null, 2);
-  }
-};
-var JsonParser = _JsonParser;
-__name(JsonParser, "JsonParser");
-JsonParser.extensions = ["json"];
-
-// src/lib/parser/yaml-parser.service.ts
-var import_yaml = require("yaml");
-var _YamlParser = class {
-  constructor() {
-    if (_YamlParser.instance) {
-      return _YamlParser.instance;
-    }
-    _YamlParser.instance = this;
-    this.logger = new Logger(this.constructor.name);
-    this.logger.trace("Created a new instance.");
-  }
-  parse(data) {
-    try {
-      return (0, import_yaml.parse)(data.toString());
-    } catch (e) {
-      this.logger.trace("Error during parsing YAML file: %s", e.message);
-      throw e;
-    }
-  }
-  stringify(data) {
-    return (0, import_yaml.stringify)(data, { prettyErrors: true });
-  }
-};
-var YamlParser = _YamlParser;
-__name(YamlParser, "YamlParser");
-YamlParser.extensions = ["yaml", "yml"];
-
-// src/lib/fs/filesystem.service.ts
-var import_fs_extra = __toESM(require("fs-extra"));
-var import_path = require("path");
-
-// src/utils/merge.ts
-var import_deepmerge = __toESM(require("deepmerge"));
-
-// src/utils/index.ts
-var import_core3 = require("@oclif/core");
-
-// src/lib/locker/locker.service.ts
-var import_object_path_immutable2 = __toESM(require("object-path-immutable"));
-
-// src/lib/store/store.service.ts
-var StoreService = class {
-  constructor() {
-    this.store = {};
-    if (StoreService.instance) {
-      return StoreService.instance;
-    } else {
-      StoreService.instance = this;
-    }
-  }
-  has(key) {
-    return !!this.store[key];
-  }
-  get(key) {
-    return this.store[key];
-  }
-  set(key, data) {
-    this.store[key] = data;
-    return data;
-  }
-};
-__name(StoreService, "StoreService");
-
-// src/lib/validator/validator.service.ts
-var import_class_transformer = require("class-transformer");
-var import_class_validator = require("class-validator");
-
 // src/hooks/store.hook.ts
 var storeHook = /* @__PURE__ */ __name((cb) => async (opts) => {
   cb(opts, new StoreService());