@cenk1cenk2/oclif-common 2.2.0 → 2.3.1-beta.1

package/dist/hooks/index.d.ts

@@ -1,3 +1,4 @@
 export { notFoundHook } from './not-found.hook.js';
 export { updateNotifierHook } from './update-notifier.hook.js';
+export { s as storeHook } from '../store.hook-06894aa2.js';
 import '@oclif/core';

package/dist/hooks/index.js

@@ -27,6 +27,7 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var hooks_exports = {};
 __export(hooks_exports, {
   notFoundHook: () => notFoundHook,
+  storeHook: () => storeHook,
   updateNotifierHook: () => updateNotifierHook
 });
 module.exports = __toCommonJS(hooks_exports);
@@ -54,10 +55,8 @@ var LogLevels = /* @__PURE__ */ ((LogLevels2) => {
   return LogLevels2;
 })(LogLevels || {});
 
-// src/utils/logger/logger.interface.ts
-var WINSTON_INSTANCE = "WINSTON_DEFAULT_LOGGER";
-
 // src/utils/logger/logger.ts
+var import_listr2 = require("listr2");
 var import_os = require("os");
 var import_winston = __toESM(require("winston"));
 
@@ -65,15 +64,12 @@ var import_winston = __toESM(require("winston"));
 var colorette = __toESM(require("colorette"));
 var color = colorette.createColors({ useColor: true });
 
-// src/utils/figures.ts
-var import_figures = __toESM(require("figures"));
-
 // src/utils/logger/logger.ts
 var Logger = class {
   constructor(context, options) {
     this.context = context;
     this.options = options;
-    const level = options?.level.toUpperCase();
+    const level = options?.level?.toUpperCase();
     this.options = {
       useIcons: true,
       ...options,
@@ -134,7 +130,7 @@ var Logger = class {
       });
       return multiLineMessage.join(import_os.EOL);
     });
-    const logger = import_winston.default.loggers.add(WINSTON_INSTANCE, {
+    const logger = import_winston.default.createLogger({
       level: this.options.level,
       format: import_winston.format.combine(import_winston.format.splat(), import_winston.format.json({ space: 2 }), import_winston.format.prettyPrint(), logFormat),
       levels: Object.values(LogLevels).reduce((o, level, i) => {
@@ -168,33 +164,33 @@ var Logger = class {
       case "DIRECT" /* DIRECT */:
         return message;
       case "FATAL" /* FATAL */:
-        coloring = /* @__PURE__ */ __name((input) => color.bgRed(color.white(input)), "coloring");
+        coloring = /* @__PURE__ */ __name((input) => color.red(input), "coloring");
         if (this.options?.useIcons) {
-          icon = import_figures.default.cross;
+          icon = import_listr2.figures.checkboxOn;
         }
         break;
       case "ERROR" /* ERROR */:
         coloring = color.red;
         if (this.options?.useIcons) {
-          icon = import_figures.default.cross;
+          icon = import_listr2.figures.cross;
         }
         break;
       case "WARN" /* WARN */:
         coloring = color.yellow;
         if (this.options?.useIcons) {
-          icon = import_figures.default.warning;
+          icon = import_listr2.figures.warning;
         }
         break;
       case "INFO" /* INFO */:
         coloring = color.green;
         if (this.options?.useIcons) {
-          icon = import_figures.default.pointerSmall;
+          icon = import_listr2.figures.pointerSmall;
         }
         break;
       case "VERBOSE" /* VERBOSE */:
         coloring = color.dim;
         if (this.options?.useIcons) {
-          icon = import_figures.default.circleQuestionMark;
+          icon = import_listr2.figures.squareSmallFilled;
         }
         break;
       case "DEBUG" /* DEBUG */:
@@ -235,8 +231,262 @@ var import_update_notifier = __toESM(require("update-notifier"));
 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_path2 = require("path");
+
+// src/lib/fs/filesystem.service.ts
+var import_fs_extra = __toESM(require("fs-extra"));
+var import_path = require("path");
+var FileSystemService = class {
+  constructor() {
+    this.logger = new Logger(this.constructor.name);
+    if (FileSystemService.instance) {
+      return FileSystemService.instance;
+    } else {
+      FileSystemService.instance = this;
+      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 deleting the directory "${directory}": ${e.message}`);
+    }
+  }
+  emptyDirSync(directory) {
+    try {
+      import_fs_extra.default.emptyDirSync(directory);
+    } catch (e) {
+      throw new Error(`Error while deleting 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 = parsers;
+    this.logger = new Logger(this.constructor.name);
+    this.fs = new FileSystemService();
+    if (_ParserService.instance) {
+      return _ParserService.instance;
+    } else {
+      _ParserService.instance = this;
+      this.logger.trace("Created a new instance.");
+    }
+  }
+  getParser(file) {
+    const ext = this.fs.extname(file);
+    const Parser = this.parsers.find((parser) => parser.extensions.includes(ext.replace(/^\./, "")));
+    if (!Parser) {
+      throw new Error(`Parser for the extension is not configured: ${ext}`);
+    }
+    return new Parser();
+  }
+  addParsers(...parsers) {
+    this.parsers.push(...parsers);
+  }
+  async read(file) {
+    const Parser = this.getParser(file);
+    return this.parse(Parser, await this.fs.read(file));
+  }
+  async write(file, data) {
+    const Parser = this.getParser(file);
+    return this.fs.write(file, await this.stringify(Parser, data));
+  }
+  parse(parser, data) {
+    return parser.parse(data);
+  }
+  stringify(parser, data) {
+    return parser.stringify(data);
+  }
+};
+var ParserService = _ParserService;
+__name(ParserService, "ParserService");
+ParserService.extensions = [];
+
+// src/utils/merge.ts
+var import_deepmerge = __toESM(require("deepmerge"));
+
+// src/lib/locker/locker.service.ts
+var import_object_path_immutable = __toESM(require("object-path-immutable"));
+
+// src/lib/parser/yaml-parser.service.ts
+var import_yaml = require("yaml");
+var _YamlParser = class {
+  constructor() {
+    this.logger = new Logger(this.constructor.name);
+    if (_YamlParser.instance) {
+      return _YamlParser.instance;
+    } else {
+      _YamlParser.instance = this;
+      this.logger.trace("Created a new instance.");
+    }
+  }
+  parse(data) {
+    try {
+      return (0, import_yaml.parse)(data.toString());
+    } catch (e) {
+      this.logger.fatal("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/parser/json-parser.service.ts
+var _JsonParser = class {
+  constructor() {
+    this.logger = new Logger(this.constructor.name);
+    if (_JsonParser.instance) {
+      return _JsonParser.instance;
+    } else {
+      _JsonParser.instance = this;
+      this.logger.trace("Created a new instance.");
+    }
+  }
+  parse(data) {
+    try {
+      return JSON.parse(data.toString());
+    } catch (e) {
+      this.logger.fatal("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/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());
+}, "storeHook");
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   notFoundHook,
+  storeHook,
   updateNotifierHook
 });

package/dist/hooks/not-found.hook.js

@@ -51,10 +51,8 @@ var LogLevels = /* @__PURE__ */ ((LogLevels2) => {
   return LogLevels2;
 })(LogLevels || {});
 
-// src/utils/logger/logger.interface.ts
-var WINSTON_INSTANCE = "WINSTON_DEFAULT_LOGGER";
-
 // src/utils/logger/logger.ts
+var import_listr2 = require("listr2");
 var import_os = require("os");
 var import_winston = __toESM(require("winston"));
 
@@ -62,15 +60,12 @@ var import_winston = __toESM(require("winston"));
 var colorette = __toESM(require("colorette"));
 var color = colorette.createColors({ useColor: true });
 
-// src/utils/figures.ts
-var import_figures = __toESM(require("figures"));
-
 // src/utils/logger/logger.ts
 var Logger = class {
   constructor(context, options) {
     this.context = context;
     this.options = options;
-    const level = options?.level.toUpperCase();
+    const level = options?.level?.toUpperCase();
     this.options = {
       useIcons: true,
       ...options,
@@ -131,7 +126,7 @@ var Logger = class {
       });
       return multiLineMessage.join(import_os.EOL);
     });
-    const logger = import_winston.default.loggers.add(WINSTON_INSTANCE, {
+    const logger = import_winston.default.createLogger({
       level: this.options.level,
       format: import_winston.format.combine(import_winston.format.splat(), import_winston.format.json({ space: 2 }), import_winston.format.prettyPrint(), logFormat),
       levels: Object.values(LogLevels).reduce((o, level, i) => {
@@ -165,33 +160,33 @@ var Logger = class {
       case "DIRECT" /* DIRECT */:
         return message;
       case "FATAL" /* FATAL */:
-        coloring = /* @__PURE__ */ __name((input) => color.bgRed(color.white(input)), "coloring");
+        coloring = /* @__PURE__ */ __name((input) => color.red(input), "coloring");
         if (this.options?.useIcons) {
-          icon = import_figures.default.cross;
+          icon = import_listr2.figures.checkboxOn;
         }
         break;
       case "ERROR" /* ERROR */:
         coloring = color.red;
         if (this.options?.useIcons) {
-          icon = import_figures.default.cross;
+          icon = import_listr2.figures.cross;
         }
         break;
       case "WARN" /* WARN */:
         coloring = color.yellow;
         if (this.options?.useIcons) {
-          icon = import_figures.default.warning;
+          icon = import_listr2.figures.warning;
         }
         break;
       case "INFO" /* INFO */:
         coloring = color.green;
         if (this.options?.useIcons) {
-          icon = import_figures.default.pointerSmall;
+          icon = import_listr2.figures.pointerSmall;
         }
         break;
       case "VERBOSE" /* VERBOSE */:
         coloring = color.dim;
         if (this.options?.useIcons) {
-          icon = import_figures.default.circleQuestionMark;
+          icon = import_listr2.figures.squareSmallFilled;
         }
         break;
       case "DEBUG" /* DEBUG */:

package/dist/hooks/store.hook.d.ts

@@ -0,0 +1,2 @@
+import '@oclif/core';
+export { s as storeHook } from '../store.hook-06894aa2.js';