@cenk1cenk2/oclif-common 4.0.1 → 4.0.3

package/dist/index.js

@@ -1,4 +1,5 @@
 "use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { newObj[key] = obj[key]; } } } newObj.default = obj; return newObj; } } function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } async function _asyncNullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return await rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
 var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
 var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
   get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
@@ -7,6 +8,10 @@ var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require
     return require.apply(this, arguments);
   throw new Error('Dynamic require of "' + x + '" is not supported');
 });
+var __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
 
 // src/commands/base.command.ts
 var _core = require('@oclif/core');
@@ -15,16 +20,16 @@ var _readline = require('readline');
 require('reflect-metadata');
 
 // src/constants/file.constants.ts
-var FileConstants = /* @__PURE__ */ ((FileConstants2) => {
+var FileConstants;
+(function(FileConstants2) {
   FileConstants2["CONFIG_SERVICE_DEFAULTS_DIR"] = "config";
-  return FileConstants2;
-})(FileConstants || {});
+})(FileConstants || (FileConstants = exports.FileConstants = {}));
 
 // src/constants/help-groups.constants.ts
-var HelpGroups = /* @__PURE__ */ ((HelpGroups2) => {
+var HelpGroups;
+(function(HelpGroups2) {
   HelpGroups2["CLI"] = "CLI";
-  return HelpGroups2;
-})(HelpGroups || {});
+})(HelpGroups || (HelpGroups = exports.HelpGroups = {}));
 
 // src/interfaces/oclif.interface.ts
 
@@ -38,7 +43,8 @@ var _os = require('os');
 var _winston = require('winston'); var _winston2 = _interopRequireDefault(_winston);
 
 // src/utils/logger/logger.constants.ts
-var LogLevels = /* @__PURE__ */ ((LogLevels2) => {
+var LogLevels;
+(function(LogLevels2) {
   LogLevels2["SILENT"] = "SILENT";
   LogLevels2["DIRECT"] = "DIRECT";
   LogLevels2["FATAL"] = "FATAL";
@@ -48,26 +54,35 @@ var LogLevels = /* @__PURE__ */ ((LogLevels2) => {
   LogLevels2["VERBOSE"] = "VERBOSE";
   LogLevels2["DEBUG"] = "DEBUG";
   LogLevels2["TRACE"] = "TRACE";
-  return LogLevels2;
-})(LogLevels || {});
-var LogFieldStatus = /* @__PURE__ */ ((LogFieldStatus2) => {
+})(LogLevels || (LogLevels = exports.LogLevels = {}));
+var LogFieldStatus;
+(function(LogFieldStatus2) {
   LogFieldStatus2["RUN"] = "run";
   LogFieldStatus2["END"] = "end";
   LogFieldStatus2["STAGE"] = "stage";
   LogFieldStatus2["EXIT"] = "exit";
   LogFieldStatus2["TERMINATE"] = "terminate";
-  return LogFieldStatus2;
-})(LogFieldStatus || {});
+})(LogFieldStatus || (LogFieldStatus = exports.LogFieldStatus = {}));
 
 // src/lib/config/config.service.ts
 var _objectpathimmutable = require('object-path-immutable'); var _objectpathimmutable2 = _interopRequireDefault(_objectpathimmutable);
 var _path = require('path');
 
+// src/lib/config/config.constants.ts
+var ConfigEnvKeys;
+(function(ConfigEnvKeys2) {
+  ConfigEnvKeys2["NAME"] = "__name";
+  ConfigEnvKeys2["PARSER"] = "__format";
+  ConfigEnvKeys2["ELEMENT"] = "__element";
+  ConfigEnvKeys2["ELEMENT_REPLACER"] = "${i}";
+})(ConfigEnvKeys || (ConfigEnvKeys = {}));
+
 // src/lib/parser/env-parser.service.ts
 
 var _EnvironmentVariableParser = class {
   constructor() {
-    this.LINE = /(?:^|^)\s*(?:export\s+)?([\w.-]+)(?:\s*=\s*?|:\s+?)(\s*'(?:\\'|[^'])*'|\s*"(?:\\"|[^"])*"|\s*`(?:\\`|[^`])*`|[^#\r\n]+)?\s*(?:#.*)?(?:$|$)/gm;
+    __publicField(this, "logger");
+    __publicField(this, "LINE", /(?:^|^)\s*(?:export\s+)?([\w.-]+)(?:\s*=\s*?|:\s+?)(\s*'(?:\\'|[^'])*'|\s*"(?:\\"|[^"])*"|\s*`(?:\\`|[^`])*`|[^#\r\n]+)?\s*(?:#.*)?(?:$|$)/gm);
     if (_EnvironmentVariableParser.instance) {
       return _EnvironmentVariableParser.instance;
     }
@@ -97,11 +112,15 @@ var _EnvironmentVariableParser = class {
 };
 var EnvironmentVariableParser = _EnvironmentVariableParser;
 __name(EnvironmentVariableParser, "EnvironmentVariableParser");
-EnvironmentVariableParser.extensions = ["env"];
+__publicField(EnvironmentVariableParser, "extensions", [
+  "env"
+]);
+__publicField(EnvironmentVariableParser, "instance");
 
 // src/lib/parser/json-parser.service.ts
 var _JsonParser = class {
   constructor() {
+    __publicField(this, "logger");
     if (_JsonParser.instance) {
       return _JsonParser.instance;
     }
@@ -123,12 +142,16 @@ var _JsonParser = class {
 };
 var JsonParser = _JsonParser;
 __name(JsonParser, "JsonParser");
-JsonParser.extensions = ["json"];
+__publicField(JsonParser, "extensions", [
+  "json"
+]);
+__publicField(JsonParser, "instance");
 
 // src/lib/parser/yaml-parser.service.ts
 var _yaml = require('yaml');
 var _YamlParser = class {
   constructor() {
+    __publicField(this, "logger");
     if (_YamlParser.instance) {
       return _YamlParser.instance;
     }
@@ -145,22 +168,29 @@ var _YamlParser = class {
     }
   }
   stringify(data) {
-    return _yaml.stringify.call(void 0, data, { prettyErrors: true });
+    return _yaml.stringify.call(void 0, data, {
+      prettyErrors: true
+    });
   }
 };
 var YamlParser = _YamlParser;
 __name(YamlParser, "YamlParser");
-YamlParser.extensions = ["yaml", "yml"];
+__publicField(YamlParser, "extensions", [
+  "yaml",
+  "yml"
+]);
+__publicField(YamlParser, "instance");
 
 // src/lib/fs/filesystem.service.ts
 var _fsextra = require('fs-extra'); var _fsextra2 = _interopRequireDefault(_fsextra);
 
-var FileSystemService = class {
+var _FileSystemService = class {
   constructor() {
-    if (FileSystemService.instance) {
-      return FileSystemService.instance;
+    __publicField(this, "logger");
+    if (_FileSystemService.instance) {
+      return _FileSystemService.instance;
     } else {
-      FileSystemService.instance = this;
+      _FileSystemService.instance = this;
       this.logger = new Logger(this.constructor.name);
       this.logger.trace("Created a new instance.");
     }
@@ -169,7 +199,9 @@ var FileSystemService = class {
     return _fsextra2.default.existsSync(path);
   }
   stats(path) {
-    return _fsextra2.default.statSync(path, { throwIfNoEntry: true });
+    return _fsextra2.default.statSync(path, {
+      throwIfNoEntry: true
+    });
   }
   dirname(path) {
     return _path.dirname.call(void 0, path);
@@ -195,14 +227,20 @@ var FileSystemService = class {
   }
   async write(file, data, options = {}) {
     try {
-      await _fsextra2.default.writeFile(file, data, typeof options === "object" ? { encoding: "utf-8", ...options } : options);
+      await _fsextra2.default.writeFile(file, data, typeof options === "object" ? {
+        encoding: "utf-8",
+        ...options
+      } : options);
     } catch (e) {
       throw new Error(`Error while writing file to "${file}": ${e.message}`);
     }
   }
   writeSync(file, data, options = {}) {
     try {
-      _fsextra2.default.writeFileSync(file, data, typeof options === "object" ? { encoding: "utf-8", ...options } : options);
+      _fsextra2.default.writeFileSync(file, data, typeof options === "object" ? {
+        encoding: "utf-8",
+        ...options
+      } : options);
     } catch (e) {
       throw new Error(`Error while writing file to "${file}": ${e.message}`);
     }
@@ -278,21 +316,29 @@ var FileSystemService = class {
     }
   }
 };
+var FileSystemService = _FileSystemService;
 __name(FileSystemService, "FileSystemService");
+__publicField(FileSystemService, "instance");
 
 // src/lib/parser/parser.service.ts
-var ParserService = class {
+var _ParserService = class {
   constructor(parsers) {
-    this.parsers = [YamlParser, JsonParser, EnvironmentVariableParser];
-    if (ParserService.instance) {
-      return ParserService.instance;
+    __publicField(this, "parsers", [
+      YamlParser,
+      JsonParser,
+      EnvironmentVariableParser
+    ]);
+    __publicField(this, "logger");
+    __publicField(this, "fs");
+    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;
+      _ParserService.instance = this;
       this.logger.trace("Created a new instance.");
     }
   }
@@ -306,17 +352,11 @@ var ParserService = class {
   }
   setParsers(...parsers) {
     this.parsers = parsers;
-    this.logger.trace(
-      "Set parsers: %s",
-      this.parsers.map((p) => p.name)
-    );
+    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)
-    );
+    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));
@@ -335,38 +375,48 @@ var ParserService = class {
     return parser.stringify(data);
   }
 };
+var ParserService = _ParserService;
 __name(ParserService, "ParserService");
+__publicField(ParserService, "instance");
 
 // src/utils/color.ts
 var _colorette = require('colorette'); var colorette = _interopRequireWildcard(_colorette);
-var color = colorette.createColors({ useColor: true });
+var color = colorette.createColors({
+  useColor: true
+});
 
 // src/utils/environment.ts
 function isVerbose(logLevel) {
-  return logLevel === "VERBOSE" /* VERBOSE */;
+  return logLevel === LogLevels.VERBOSE;
 }
 __name(isVerbose, "isVerbose");
 function isDebug(logLevel) {
-  return ["DEBUG" /* DEBUG */, "TRACE" /* TRACE */].includes(logLevel);
+  return [
+    LogLevels.DEBUG,
+    LogLevels.TRACE
+  ].includes(logLevel);
 }
 __name(isDebug, "isDebug");
 function isSilent(logLevel) {
-  return logLevel === "SILENT" /* SILENT */;
+  return logLevel === LogLevels.SILENT;
 }
 __name(isSilent, "isSilent");
 
 // src/utils/merge.constants.ts
-var MergeStrategy = /* @__PURE__ */ ((MergeStrategy2) => {
+var MergeStrategy;
+(function(MergeStrategy2) {
   MergeStrategy2["OVERWRITE"] = "OVERWRITE";
   MergeStrategy2["EXTEND"] = "EXTEND";
-  return MergeStrategy2;
-})(MergeStrategy || {});
+})(MergeStrategy || (MergeStrategy = exports.MergeStrategy = {}));
 
 // src/utils/merge.ts
 var _deepmerge = require('deepmerge'); var _deepmerge2 = _interopRequireDefault(_deepmerge);
 function merge(strategy, ...source) {
   return _deepmerge2.default.all(source, {
-    arrayMerge: strategy === "EXTEND" /* EXTEND */ ? (dest, src) => [...dest, ...src].filter(uniqueFilter) : (_, src) => src
+    arrayMerge: strategy === MergeStrategy.EXTEND ? (dest, src) => [
+      ...dest,
+      ...src
+    ].filter(uniqueFilter) : (_, src) => src
   });
 }
 __name(merge, "merge");
@@ -399,20 +449,34 @@ __name(setCtxAssign, "setCtxAssign");
 
 
 // src/lib/config/config.service.ts
-var ConfigService = class {
+var _ConfigService = class {
   constructor(oclif, command, config) {
+    __publicField(this, "oclif");
+    __publicField(this, "command");
+    __publicField(this, "defaults");
+    __publicField(this, "root");
+    __publicField(this, "parser");
+    __publicField(this, "logLevel");
+    __publicField(this, "isVerbose");
+    __publicField(this, "isDebug");
+    __publicField(this, "isSilent");
+    __publicField(this, "ci");
+    __publicField(this, "json");
+    __publicField(this, "logger");
     this.oclif = oclif;
     this.command = command;
-    if (ConfigService.instance) {
-      return ConfigService.instance;
+    if (_ConfigService.instance) {
+      return _ConfigService.instance;
     }
     this.root = this.oclif.root;
-    this.defaults = _path.join.call(void 0, this.oclif.root, "config" /* CONFIG_SERVICE_DEFAULTS_DIR */);
-    this.logger = new Logger(this.constructor.name, { level: config.logLevel });
+    this.defaults = _path.join.call(void 0, this.oclif.root, FileConstants.CONFIG_SERVICE_DEFAULTS_DIR);
+    this.logger = new Logger(this.constructor.name, {
+      level: config.logLevel
+    });
     Object.assign(this, config);
     this.recalculate();
     this.parser = new ParserService();
-    ConfigService.instance = this;
+    _ConfigService.instance = this;
     this.logger.trace("Created a new instance.");
   }
   async read(path) {
@@ -420,22 +484,20 @@ var ConfigService = class {
     this.logger.trace("Read config from: %s", path);
     return config;
   }
-  async extend(paths, strategy = "OVERWRITE" /* OVERWRITE */) {
+  async extend(paths, strategy = MergeStrategy.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);
+    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 */) {
+  merge(configs, strategy = MergeStrategy.OVERWRITE) {
     if (configs.length === 0) {
       throw new Error("Nothing to merge, configuration files are empty.");
     }
@@ -445,35 +507,44 @@ var ConfigService = class {
     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 = [..._nullishCoalesce(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,
-                  // eslint-disable-next-line no-underscore-dangle
-                  env: value["__name" /* NAME */],
-                  // eslint-disable-next-line no-underscore-dangle
-                  parser: value["__format" /* PARSER */],
-                  extensions
-                }
-              ];
-              return variable;
-            } else {
-              return iter(value, location);
+      const data = await Promise.all(Object.entries(obj).map(async ([key, value]) => {
+        const location = [
+          ..._nullishCoalesce(parent, () => ( [])),
+          key
+        ];
+        if (typeof value === "string") {
+          return [
+            {
+              key: location,
+              env: value
             }
+          ];
+        } else if (typeof value === "object") {
+          let extensions;
+          if (ConfigEnvKeys.ELEMENT in value) {
+            extensions = await iter(value[ConfigEnvKeys.ELEMENT], [
+              ...location,
+              ConfigEnvKeys.ELEMENT
+            ]);
+            this.logger.trace("Expanding location to elements: %s -> %s", location, extensions.map((extension) => extension.key.join(".")).join(", "));
           }
-        })
-      );
+          if (ConfigEnvKeys.NAME in value && ConfigEnvKeys.PARSER in value) {
+            const variable = [
+              {
+                key: location,
+                // eslint-disable-next-line no-underscore-dangle
+                env: value[ConfigEnvKeys.NAME],
+                // eslint-disable-next-line no-underscore-dangle
+                parser: value[ConfigEnvKeys.PARSER],
+                extensions
+              }
+            ];
+            return variable;
+          } else {
+            return iter(value, location);
+          }
+        }
+      }));
       return data.flatMap((d) => d).filter(Boolean);
     }, "iter");
     const parsed = await iter(env);
@@ -504,8 +575,8 @@ var ConfigService = class {
           }
           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();
+            clone.env = clone.env.replace(ConfigEnvKeys.ELEMENT_REPLACER, i.toString());
+            clone.key[clone.key.findIndex((value) => value === ConfigEnvKeys.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);
@@ -532,12 +603,21 @@ var ConfigService = class {
     this.isSilent = isSilent(this.logLevel);
   }
 };
+var ConfigService = _ConfigService;
 __name(ConfigService, "ConfigService");
+__publicField(ConfigService, "instance");
 
 // src/lib/locker/locker.service.ts
 
 var LockerService = class {
   constructor(file, parser, root, context) {
+    __publicField(this, "file");
+    __publicField(this, "parser");
+    __publicField(this, "root");
+    __publicField(this, "toLock");
+    __publicField(this, "toUnlock");
+    __publicField(this, "logger");
+    __publicField(this, "fs");
     this.file = file;
     this.parser = parser;
     this.root = root;
@@ -557,10 +637,16 @@ var LockerService = class {
     return this.toUnlock.length > 0;
   }
   addLock(...data) {
-    this.toLock = [...this.toLock, ...data];
+    this.toLock = [
+      ...this.toLock,
+      ...data
+    ];
   }
   addUnlock(...data) {
-    this.toUnlock = [...this.toUnlock, ...data];
+    this.toUnlock = [
+      ...this.toUnlock,
+      ...data
+    ];
   }
   async lockAll() {
     if (this.hasLock()) {
@@ -654,7 +740,10 @@ var LockerService = class {
   }
   buildPath(d) {
     if (_optionalChain([d, 'optionalAccess', _13 => _13.root]) !== true && _optionalChain([this, 'access', _14 => _14.root, 'optionalAccess', _15 => _15.length])) {
-      return [...this.root, ...this.normalizePath(d.path)];
+      return [
+        ...this.root,
+        ...this.normalizePath(d.path)
+      ];
     }
     return this.normalizePath(d.path);
   }
@@ -670,13 +759,13 @@ var LockerService = class {
 __name(LockerService, "LockerService");
 
 // src/lib/store/store.service.ts
-var StoreService = class {
+var _StoreService = class {
   constructor() {
-    this.store = {};
-    if (StoreService.instance) {
-      return StoreService.instance;
+    __publicField(this, "store", {});
+    if (_StoreService.instance) {
+      return _StoreService.instance;
     } else {
-      StoreService.instance = this;
+      _StoreService.instance = this;
     }
   }
   has(key) {
@@ -690,16 +779,20 @@ var StoreService = class {
     return data;
   }
 };
+var StoreService = _StoreService;
 __name(StoreService, "StoreService");
+__publicField(StoreService, "instance");
 
 // src/lib/validator/validator.service.ts
 var _classtransformer = require('class-transformer');
 var _classvalidator = require('class-validator');
-var ValidatorService = class {
+var _ValidatorService = class {
   constructor(options) {
+    __publicField(this, "options");
+    __publicField(this, "logger");
     this.options = options;
-    if (ValidatorService.instance) {
-      return ValidatorService.instance;
+    if (_ValidatorService.instance) {
+      return _ValidatorService.instance;
     }
     this.options = {
       validator: {
@@ -708,16 +801,24 @@ var ValidatorService = class {
         always: true,
         enableDebugMessages: true
       },
-      transformer: { enableImplicitConversion: true },
+      transformer: {
+        enableImplicitConversion: true
+      },
       ..._nullishCoalesce(options, () => ( {}))
     };
     this.logger = new Logger(this.constructor.name);
-    ValidatorService.instance = this;
+    _ValidatorService.instance = this;
     this.logger.trace("Created a new instance.");
   }
   async validate(classType, object, options) {
-    const classObject = _classtransformer.plainToClass.call(void 0, classType, object, { ...this.options.transformer, ..._nullishCoalesce(_optionalChain([options, 'optionalAccess', _16 => _16.transformer]), () => ( {})) });
-    const errors = await _classvalidator.validate.call(void 0, classObject, { ...this.options.validator, ..._nullishCoalesce(_optionalChain([options, 'optionalAccess', _17 => _17.validator]), () => ( {})) });
+    const classObject = _classtransformer.plainToClass.call(void 0, classType, object, {
+      ...this.options.transformer,
+      ..._nullishCoalesce(_optionalChain([options, 'optionalAccess', _16 => _16.transformer]), () => ( {}))
+    });
+    const errors = await _classvalidator.validate.call(void 0, classObject, {
+      ...this.options.validator,
+      ..._nullishCoalesce(_optionalChain([options, 'optionalAccess', _17 => _17.validator]), () => ( {}))
+    });
     if (errors.length) {
       errors.forEach((error) => {
         this.logValidationError(error);
@@ -727,8 +828,14 @@ var ValidatorService = class {
     return classObject;
   }
   validateSync(classType, object, options) {
-    const classObject = _classtransformer.plainToClass.call(void 0, classType, object, { ...this.options.transformer, ..._nullishCoalesce(_optionalChain([options, 'optionalAccess', _18 => _18.transformer]), () => ( {})) });
-    const errors = _classvalidator.validateSync.call(void 0, classObject, { ...this.options.validator, ..._nullishCoalesce(_optionalChain([options, 'optionalAccess', _19 => _19.validator]), () => ( {})) });
+    const classObject = _classtransformer.plainToClass.call(void 0, classType, object, {
+      ...this.options.transformer,
+      ..._nullishCoalesce(_optionalChain([options, 'optionalAccess', _18 => _18.transformer]), () => ( {}))
+    });
+    const errors = _classvalidator.validateSync.call(void 0, classObject, {
+      ...this.options.validator,
+      ..._nullishCoalesce(_optionalChain([options, 'optionalAccess', _19 => _19.validator]), () => ( {}))
+    });
     if (errors.length) {
       errors.forEach((error) => {
         this.logValidationError(error);
@@ -741,7 +848,9 @@ var ValidatorService = class {
     this.logger.error('Field "%s" failed validation with value "%s": %o', err.property, err.value, err.constraints);
   }
 };
+var ValidatorService = _ValidatorService;
 __name(ValidatorService, "ValidatorService");
+__publicField(ValidatorService, "instance");
 
 // src/lib/setup.ts
 function setup() {
@@ -779,14 +888,17 @@ function setup() {
 __name(setup, "setup");
 
 // src/utils/logger/logger.ts
-var Logger = class {
+var _Logger = class {
   constructor(context, options) {
+    __publicField(this, "context");
+    __publicField(this, "options");
+    __publicField(this, "logger");
     this.context = context;
     this.options = options;
-    if (Logger.instance) {
-      this.logger = Logger.instance;
+    if (_Logger.instance) {
+      this.logger = _Logger.instance;
     } else if (context === ConfigService.name) {
-      const level = Object.values(LogLevels).includes(_optionalChain([options, 'optionalAccess', _20 => _20.level])) ? options.level : "INFO" /* INFO */;
+      const level = Object.values(LogLevels).includes(_optionalChain([options, 'optionalAccess', _20 => _20.level])) ? options.level : LogLevels.INFO;
       this.options = {
         useIcons: true,
         ...options,
@@ -794,7 +906,7 @@ var Logger = class {
       };
       this.logger = this.initiateLogger();
       this.trace("Logger singleton initiated from context: %s", context);
-      Logger.instance = this.logger;
+      _Logger.instance = this.logger;
     } else {
       throw new Error("Logger can only be initiated inside the config service context!");
     }
@@ -803,38 +915,44 @@ var Logger = class {
     return this.parseMessage(level, data, args);
   }
   direct(data, ...args) {
-    return this.parseMessage("DIRECT" /* DIRECT */, data, args);
+    return this.parseMessage(LogLevels.DIRECT, data, args);
   }
   fatal(data, ...args) {
-    return this.parseMessage("FATAL" /* FATAL */, data, args);
+    return this.parseMessage(LogLevels.FATAL, data, args);
   }
   error(data, ...args) {
-    return this.parseMessage("ERROR" /* ERROR */, data, args);
+    return this.parseMessage(LogLevels.ERROR, data, args);
   }
   warn(data, ...args) {
-    return this.parseMessage("WARN" /* WARN */, data, args);
+    return this.parseMessage(LogLevels.WARN, data, args);
   }
   info(data, ...args) {
-    return this.parseMessage("INFO" /* INFO */, data, args);
+    return this.parseMessage(LogLevels.INFO, data, args);
   }
   debug(data, ...args) {
-    return this.parseMessage("DEBUG" /* DEBUG */, data, args);
+    return this.parseMessage(LogLevels.DEBUG, data, args);
   }
   verbose(data, ...args) {
-    return this.parseMessage("VERBOSE" /* VERBOSE */, data, args);
+    return this.parseMessage(LogLevels.VERBOSE, data, args);
   }
   trace(data, ...args) {
-    return this.parseMessage("TRACE" /* TRACE */, data, args);
+    return this.parseMessage(LogLevels.TRACE, data, args);
   }
   // status levels
   run(data, ...args) {
-    return this.parseMessage("INFO" /* INFO */, data, args, { status: "run" /* RUN */ });
+    return this.parseMessage(LogLevels.INFO, data, args, {
+      status: LogFieldStatus.RUN
+    });
   }
   end(data, ...args) {
-    return this.parseMessage("INFO" /* INFO */, data, args, { status: "end" /* END */ });
+    return this.parseMessage(LogLevels.INFO, data, args, {
+      status: LogFieldStatus.END
+    });
   }
   stage(data, ...args) {
-    return this.parseMessage("TRACE" /* TRACE */, data, args, { status: "stage" /* STAGE */ });
+    return this.parseMessage(LogLevels.TRACE, data, args, {
+      status: LogFieldStatus.STAGE
+    });
   }
   initiateLogger() {
     const logFormat = _winston.format.printf(({ level, message, context, status }) => {
@@ -853,30 +971,40 @@ var Logger = class {
     });
     const logger = _winston2.default.createLogger({
       level: this.options.level,
-      format: _winston.format.combine(_winston.format.splat(), _winston.format.json({ space: 2 }), _winston.format.prettyPrint(), logFormat),
+      format: _winston.format.combine(_winston.format.splat(), _winston.format.json({
+        space: 2
+      }), _winston.format.prettyPrint(), logFormat),
       levels: Object.values(LogLevels).reduce((o, level, i) => {
         return {
           ...o,
           [level]: i
         };
       }, {}),
-      silent: this.options.level === "SILENT" /* SILENT */,
+      silent: this.options.level === LogLevels.SILENT,
       transports: [
         new _winston.transports.Console({
-          stderrLevels: ["FATAL" /* FATAL */, "ERROR" /* ERROR */]
+          stderrLevels: [
+            LogLevels.FATAL,
+            LogLevels.ERROR
+          ]
         })
       ]
     });
-    logger.log("TRACE" /* TRACE */, "Initiated new logger with level: %s", this.options.level, { context: this.constructor.name });
+    logger.log(LogLevels.TRACE, "Initiated new logger with level: %s", this.options.level, {
+      context: this.constructor.name
+    });
     return logger;
   }
   parseMessage(level, data, args, format2) {
-    if (!this.logger && !Logger.instance) {
+    if (!this.logger && !_Logger.instance) {
       return;
-    } else if (Logger.instance) {
-      this.logger = Logger.instance;
+    } else if (_Logger.instance) {
+      this.logger = _Logger.instance;
     }
-    this.logger.log(level, data.toString(), ..._nullishCoalesce(args, () => ( [])), { context: this.context, ..._nullishCoalesce(format2, () => ( {})) });
+    this.logger.log(level, data.toString(), ..._nullishCoalesce(args, () => ( [])), {
+      context: this.context,
+      ..._nullishCoalesce(format2, () => ( {}))
+    });
   }
   logColoring({ level, message, context, status }) {
     let icon;
@@ -887,46 +1015,46 @@ var Logger = class {
       return input;
     }, "msgColoring");
     switch (level) {
-      case "DIRECT" /* DIRECT */:
+      case LogLevels.DIRECT:
         return message;
-      case "FATAL" /* FATAL */:
+      case LogLevels.FATAL:
         coloring = /* @__PURE__ */ __name((input) => color.red(input), "coloring");
         if (_optionalChain([this, 'access', _21 => _21.options, 'optionalAccess', _22 => _22.useIcons])) {
           icon = _listr2.figures.checkboxOn;
         }
         break;
-      case "ERROR" /* ERROR */:
+      case LogLevels.ERROR:
         coloring = color.red;
         if (_optionalChain([this, 'access', _23 => _23.options, 'optionalAccess', _24 => _24.useIcons])) {
           icon = _listr2.figures.cross;
         }
         break;
-      case "WARN" /* WARN */:
+      case LogLevels.WARN:
         coloring = color.yellow;
         if (_optionalChain([this, 'access', _25 => _25.options, 'optionalAccess', _26 => _26.useIcons])) {
           icon = _listr2.figures.warning;
         }
         break;
-      case "INFO" /* INFO */:
+      case LogLevels.INFO:
         coloring = color.green;
         if (_optionalChain([this, 'access', _27 => _27.options, 'optionalAccess', _28 => _28.useIcons])) {
           icon = _listr2.figures.pointerSmall;
         }
         break;
-      case "VERBOSE" /* VERBOSE */:
+      case LogLevels.VERBOSE:
         coloring = color.dim;
         if (_optionalChain([this, 'access', _29 => _29.options, 'optionalAccess', _30 => _30.useIcons])) {
           icon = "\u2607";
         }
         break;
-      case "DEBUG" /* DEBUG */:
+      case LogLevels.DEBUG:
         coloring = color.cyan;
         msgColoring = color.dim;
         if (_optionalChain([this, 'access', _31 => _31.options, 'optionalAccess', _32 => _32.useIcons])) {
           icon = "\uF188";
         }
         break;
-      case "TRACE" /* TRACE */:
+      case LogLevels.TRACE:
         coloring = color.magenta;
         msgColoring = color.dim;
         if (_optionalChain([this, 'access', _33 => _33.options, 'optionalAccess', _34 => _34.useIcons])) {
@@ -940,37 +1068,50 @@ var Logger = class {
     return `${coloring(icon)}${context ? " " + coloring(`[${context}]`) : ""}${status ? " " + coloring(`[${status}]`) : ""} ${msgColoring(message)}`;
   }
 };
+var Logger = _Logger;
 __name(Logger, "Logger");
+__publicField(Logger, "instance");
 
 // src/utils/logger/listr-logger.ts
 var ListrLogger = class extends _listr2.Logger {
   constructor(context) {
     super();
+    __publicField(this, "logger");
     this.logger = new Logger(context);
   }
   fail(message) {
     this.logger.error(message);
   }
   skip(message) {
-    this.logger.warn(message, { status: "skip" });
+    this.logger.warn(message, {
+      status: "skip"
+    });
   }
   success(message) {
-    this.logger.info(message, { status: "end" });
+    this.logger.info(message, {
+      status: "end"
+    });
   }
   data(message) {
     this.logger.info(message);
   }
   start(message) {
-    this.logger.info(message, { status: "run" });
+    this.logger.info(message, {
+      status: "run"
+    });
   }
   title(message) {
     this.logger.info(message);
   }
   retry(message) {
-    this.logger.warn(message, { status: "retry" });
+    this.logger.warn(message, {
+      status: "retry"
+    });
   }
   rollback(message) {
-    this.logger.error(message, { status: "rollback" });
+    this.logger.error(message, {
+      status: "rollback"
+    });
   }
 };
 __name(ListrLogger, "ListrLogger");
@@ -991,42 +1132,54 @@ __name(pipeProcessThroughListr, "pipeProcessThroughListr");
 
 function pipeProcessToLogger(logger, instance, options) {
   options = {
-    start: "INFO" /* INFO */,
-    end: "INFO" /* INFO */,
-    stdout: "INFO" /* INFO */,
-    stderr: "WARN" /* WARN */,
+    start: LogLevels.INFO,
+    end: LogLevels.INFO,
+    stdout: LogLevels.INFO,
+    stderr: LogLevels.WARN,
     ...options
   };
   if (options.start) {
-    logger.run(instance.spawnargs.join(" "), { level: options.start, context: options.context });
+    logger.run(instance.spawnargs.join(" "), {
+      level: options.start,
+      context: options.context
+    });
   }
   if (instance.stdout) {
-    instance.stdout.pipe(
-      _through2.default.call(void 0, (chunk) => {
-        logger.log(options.stdout, chunk, { context: options.context });
-      })
-    );
+    instance.stdout.pipe(_through2.default.call(void 0, (chunk) => {
+      logger.log(options.stdout, chunk, {
+        context: options.context
+      });
+    }));
   }
   if (instance.stderr) {
-    instance.stderr.pipe(
-      _through2.default.call(void 0, (chunk) => {
-        logger.log(options.stderr, chunk, { context: options.context });
-      })
-    );
+    instance.stderr.pipe(_through2.default.call(void 0, (chunk) => {
+      logger.log(options.stderr, chunk, {
+        context: options.context
+      });
+    }));
   }
   void instance.on("exit", (code, signal) => {
     const message = `Process ended with code ${code}${signal ? ` and signal ${signal}` : ""}.`;
-    logger.debug(message, { context: options.context });
+    logger.debug(message, {
+      context: options.context
+    });
     if (options.end) {
-      logger.end(instance.spawnargs.join(" "), { level: options.end, context: options.context });
+      logger.end(instance.spawnargs.join(" "), {
+        level: options.end,
+        context: options.context
+      });
     }
     if (_optionalChain([options, 'optionalAccess', _39 => _39.callback])) {
       options.callback();
     }
   });
   void instance.on("error", (error) => {
-    logger.fatal(error.message, { context: options.context });
-    logger.debug(error.stack, { context: options.context });
+    logger.fatal(error.message, {
+      context: options.context
+    });
+    logger.debug(error.stack, {
+      context: options.context
+    });
     if (_optionalChain([options, 'optionalAccess', _40 => _40.callback])) {
       options.callback(error);
     }
@@ -1038,11 +1191,11 @@ __name(pipeProcessToLogger, "pipeProcessToLogger");
 // src/constants/global-flags.constants.ts
 var CLI_FLAGS = {
   ["log-level"]: _core.Flags.string({
-    default: "INFO" /* INFO */,
+    default: LogLevels.INFO,
     env: "LOG_LEVEL",
     description: "Set the log level of the application.",
     options: Object.values(LogLevels).map((level) => level.toLowerCase()),
-    helpGroup: "CLI" /* CLI */,
+    helpGroup: HelpGroups.CLI,
     parse: async (input) => _optionalChain([input, 'optionalAccess', _41 => _41.toUpperCase, 'call', _42 => _42()])
   }),
   ci: _core.Flags.boolean({
@@ -1050,14 +1203,14 @@ var CLI_FLAGS = {
     hidden: true,
     env: "CI",
     description: "Instruct whether this is running the CI/CD configuration.",
-    helpGroup: "CLI" /* CLI */
+    helpGroup: HelpGroups.CLI
   }),
   json: _core.Flags.boolean({
     default: false,
     hidden: true,
     env: "JSON",
     description: "Put the CLI to respond in JSON.",
-    helpGroup: "CLI" /* CLI */
+    helpGroup: HelpGroups.CLI
   })
 };
 
@@ -1065,8 +1218,16 @@ var CLI_FLAGS = {
 var Command = class extends _core.Command {
   constructor() {
     super(...arguments);
-    this.flags = {};
-    this.args = {};
+    __publicField(this, "context");
+    __publicField(this, "logger");
+    __publicField(this, "tasks");
+    __publicField(this, "validator");
+    __publicField(this, "cs");
+    __publicField(this, "parser");
+    __publicField(this, "fs");
+    __publicField(this, "store");
+    __publicField(this, "flags", {});
+    __publicField(this, "args", {});
   }
   static get baseFlags() {
     return this._baseFlags;
@@ -1076,14 +1237,14 @@ var Command = class extends _core.Command {
     this.flags = {};
   }
   /**
-   * Construct the class if you dont want to extend init or constructor.
-   */
+  * Construct the class if you dont want to extend init or constructor.
+  */
   // eslint-disable-next-line @typescript-eslint/no-empty-function
   shouldRunBefore() {
   }
   /**
-   * Deconstruct the class if you dont want to extend finally or catch.
-   */
+  * Deconstruct the class if you dont want to extend finally or catch.
+  */
   // eslint-disable-next-line @typescript-eslint/no-empty-function, @typescript-eslint/no-unused-vars
   shouldRunAfter(_ctx) {
   }
@@ -1108,7 +1269,9 @@ var Command = class extends _core.Command {
     return result;
   }
   exit(code) {
-    this.logger.trace("Code -> %d", code, { status: "exit" /* EXIT */ });
+    this.logger.trace("Code -> %d", code, {
+      status: LogFieldStatus.EXIT
+    });
     process.exit(_nullishCoalesce(code, () => ( 0)));
   }
   /** Run all tasks from task manager. */
@@ -1124,11 +1287,15 @@ var Command = class extends _core.Command {
   }
   setCtxDefaults(...defaults) {
     setCtxDefaults(this.tasks.options.ctx, ...defaults);
-    this.logger.trace("Updated context with defaults: %o", this.tasks.options.ctx, { status: "ctx" });
+    this.logger.trace("Updated context with defaults: %o", this.tasks.options.ctx, {
+      status: "ctx"
+    });
   }
   setCtxAssign(...assigns) {
     setCtxAssign(this.tasks.options.ctx, ...assigns);
-    this.logger.trace("Updated context with assign: %o", this.tasks.options.ctx, { status: "ctx" });
+    this.logger.trace("Updated context with assign: %o", this.tasks.options.ctx, {
+      status: "ctx"
+    });
   }
   pipeProcessToLogger(instance, options) {
     return pipeProcessToLogger(this.logger, instance, options);
@@ -1155,7 +1322,9 @@ var Command = class extends _core.Command {
       json: this.flags.json
     });
     this.context = this.cs.command.id ? this.cs.command.id : this.cs.command.name;
-    this.logger = new Logger(null, { level: this.cs.logLevel });
+    this.logger = new Logger(null, {
+      level: this.cs.logLevel
+    });
     this.store = new StoreService();
     this.greet();
     if (err) {
@@ -1184,7 +1353,9 @@ var Command = class extends _core.Command {
       });
     }
     const terminate = /* @__PURE__ */ __name(() => {
-      this.logger.fatal("Caught terminate signal.", { status: "terminate" /* TERMINATE */ });
+      this.logger.fatal("Caught terminate signal.", {
+        status: LogFieldStatus.TERMINATE
+      });
       process.exit(1);
     }, "terminate");
     process.on("SIGINT", terminate);
@@ -1201,7 +1372,9 @@ var Command = class extends _core.Command {
     this.logger.stage("Running shouldRunAfter.");
     await this.shouldRunAfter(ctx);
     this.logger.stage("Finished shouldRunAfter.");
-    return { ctx };
+    return {
+      ctx
+    };
   }
   /** Catch any error occurred during command. */
   // catch all those errors, not verbose
@@ -1212,7 +1385,9 @@ var Command = class extends _core.Command {
       console.debug(e.stack);
     }
     this.logger.fatal(e.message);
-    this.logger.debug(e.stack, { context: "crash" });
+    this.logger.debug(e.stack, {
+      context: "crash"
+    });
     if (exit > 0) {
       this.exit(exit);
     }
@@ -1233,6 +1408,11 @@ __name(Command, "Command");
 
 // src/commands/config.command.ts
 var ConfigCommand = class extends Command {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "choices");
+    __publicField(this, "locker");
+  }
   async run() {
     this.logger.stage("Setting up config command.");
     const setup2 = await this.setup();
@@ -1264,17 +1444,28 @@ __name(ConfigCommand, "ConfigCommand");
 
 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.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 (0, _core.Help)(opts.config);
-  await help.showHelp(["--all"]);
+  await help.showHelp([
+    "--all"
+  ]);
   process.exit(127);
 }, "notFoundHook");
 
 // src/hooks/update-notifier.hook.ts
-var _updatenotifier = require('update-notifier'); var _updatenotifier2 = _interopRequireDefault(_updatenotifier);
 var updateNotifierHook = /* @__PURE__ */ __name(async (opts) => {
-  _updatenotifier2.default.call(void 0, { pkg: { name: opts.config.name, version: opts.config.version } }).notify({ isGlobal: true });
+  const { default: notifier } = await Promise.resolve().then(() => _interopRequireWildcard(require("update-notifier")));
+  notifier({
+    pkg: {
+      name: opts.config.name,
+      version: opts.config.version
+    }
+  }).notify({
+    isGlobal: true
+  });
 }, "updateNotifierHook");
 
 // src/hooks/store.hook.ts

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cenk1cenk2/oclif-common",
-  "version": "4.0.1",
+  "version": "4.0.3",
   "description": "Oclif common package for oclif2 projects.",
   "repository": "https://gitlab.kilic.dev/libraries/oclif-tools",
   "author": {
@@ -57,7 +57,7 @@
   },
   "dependencies": {
     "colorette": "^2.0.19",
-    "deepmerge": "^4.3.0",
+    "deepmerge": "^4.3.1",
     "object-path-immutable": "^4.1.2",
     "reflect-metadata": "^0.1.13",
     "through": "^2.3.8",
@@ -66,7 +66,7 @@
     "yaml": "^2.2.1"
   },
   "devDependencies": {
-    "@oclif/core": "^2.6.2",
+    "@oclif/core": "^2.8.0",
     "@types/fs-extra": "^11.0.1",
     "@types/through": "^0.0.30",
     "@types/update-notifier": "^6.0.2",
@@ -74,7 +74,7 @@
     "class-validator": "^0.14.0",
     "enquirer": "^2.3.6",
     "execa": "^5.1.1",
-    "fs-extra": "^11.1.0",
+    "fs-extra": "^11.1.1",
     "listr2": "^5.0.8"
   }
 }