@cenk1cenk2/oclif-common 3.7.1 → 3.8.0

package/dist/hooks/store.hook.js

@@ -77,8 +77,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;
     }
   }
@@ -153,6 +154,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 }) {
@@ -249,6 +255,42 @@ var CLI_FLAGS = {
   })
 };
 
+// src/lib/parser/env-parser.service.ts
+var import_os2 = 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_os2.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_os2.EOL) + import_os2.EOL;
+  }
+};
+var EnvironmentVariableParser = _EnvironmentVariableParser;
+__name(EnvironmentVariableParser, "EnvironmentVariableParser");
+EnvironmentVariableParser.extensions = ["env"];
+
 // src/lib/parser/json-parser.service.ts
 var _JsonParser = class {
   constructor() {
@@ -305,13 +347,354 @@ 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/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"));
 

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-import { Command as Command$1, Config, CliUx } from '@oclif/core';
+import { Command as Command$1, CliUx } from '@oclif/core';
 export { CliUx, Flags } from '@oclif/core';
 import { Logger as Logger$2, ListrTaskWrapper, ListrContext, Manager, PromptOptions } from 'listr2';
 import { Logger as Logger$1, LeveledLogMethod } from 'winston';
@@ -61,7 +61,7 @@ declare type Winston = Logger$1 & Record<keyof typeof LogLevels, LeveledLogMetho
 declare class Logger {
     private context?;
     private options?;
-    private static instance;
+    static instance: Winston;
     private logger;
     constructor(context?: string, options?: LoggerOptions);
     log(level: LogLevels, data: string | Buffer, ...args: any): void;
@@ -144,7 +144,8 @@ declare enum MergeStrategy {
 
 /** Merge objects deep from overwriting the properties from source to target.
  * Does not mutate the object */
-declare function merge<T extends Record<PropertyKey, any> | any[]>(strategy: MergeStrategy, target: T, ...source: Partial<T>[]): T;
+declare function merge<T extends Record<PropertyKey, any> | any[]>(strategy: MergeStrategy, ...source: Partial<T>[]): T;
+declare function uniqueFilter(value: any, index: any, self: string | any[]): boolean;
 
 declare type SetCtxDefaultsOptions<T extends ListrContext = ListrContext> = Partial<T>;
 interface SetCtxAssignOptions<K = Record<PropertyKey, any>> {
@@ -155,7 +156,7 @@ declare function setCtxDefaults<T extends ListrContext = ListrContext>(ctx: T, .
 declare function setCtxAssign<T extends ListrContext = ListrContext, K = Record<PropertyKey, any>>(ctx: T, ...assigns: SetCtxAssignOptions<K>[]): void;
 
 interface CommonLockerData {
-    path: string | string[];
+    path?: string | string[];
     enabled?: boolean;
     root?: boolean;
 }
@@ -165,6 +166,7 @@ interface LockData<T extends LockableData = LockableData> extends Partial<Common
     merge?: MergeStrategy;
 }
 interface UnlockData extends CommonLockerData {
+    path: string | string[];
 }
 
 declare class GenericParser {
@@ -175,13 +177,13 @@ declare class GenericParser {
 
 declare class LockerService<LockFile extends LockableData = LockableData> {
     private file;
-    private parser;
+    private parser?;
     private root?;
     private toLock;
     private toUnlock;
     private logger;
     private fs;
-    constructor(file: string, parser: GenericParser, root?: string, context?: string);
+    constructor(file: string, parser?: GenericParser, root?: string[], context?: string);
     hasLock(): boolean;
     hasUnlock(): boolean;
     addLock<T extends LockableData = LockableData>(...data: LockData<T>[]): void;
@@ -254,10 +256,22 @@ declare class FileSystemService {
     removeSync(file: string, options?: fs.RmOptions): void;
     emptyDir(directory: string): Promise<void>;
     emptyDirSync(directory: string): void;
+    removeDir(directory: string): Promise<void>;
+    removeDirSync(directory: string): void;
     mkdir(directory: string): Promise<void>;
     mkdirSync(directory: string): void;
 }
 
+declare class EnvironmentVariableParser implements GenericParser {
+    static extensions: string[];
+    private static instance;
+    private logger;
+    private LINE;
+    constructor();
+    parse<T = unknown>(data: string | Buffer): T;
+    stringify<T = any>(data: T): string;
+}
+
 declare class YamlParser implements GenericParser {
     static extensions: string[];
     private static instance;
@@ -310,8 +324,6 @@ declare type DeepPartial<T> = {
 };
 
 declare class Command<Ctx extends ListrContext = ListrContext, Flags extends Record<PropertyKey, any> = InferFlags<typeof Command>, Args extends Record<PropertyKey, any> = InferArgs<typeof Command>, Store extends Record<PropertyKey, any> = Record<PropertyKey, any>> extends Command$1 {
-    argv: string[];
-    config: Config;
     static get globalFlags(): FlagInput;
     static set globalFlags(flags: FlagInput);
     logger: Logger;
@@ -323,7 +335,6 @@ declare class Command<Ctx extends ListrContext = ListrContext, Flags extends Rec
     store: StoreService<Store>;
     flags: Flags;
     args: Args;
-    constructor(argv: string[], config: Config);
     /**
      * Construct the class if you dont want to extend init or constructor.
      */
@@ -348,7 +359,7 @@ declare class Command<Ctx extends ListrContext = ListrContext, Flags extends Rec
         ctx: C;
     }>;
     /** Catch any error occurred during command. */
-    protected catch(e: Error): Promise<void>;
+    protected catch(e: Error, exit?: number): Promise<void>;
     private greet;
 }
 
@@ -398,4 +409,4 @@ declare enum HelpGroups {
     CLI = "CLI"
 }
 
-export { CLI_FLAGS, ClassType, Command, CommonLockerData, ConfigCommand, ConfigCommandChoices, ConfigCommandSetup, ConfigIterator, ConfigService, DeepPartial, FileConstants, FileSystemService, GenericParser, GlobalConfig, GlobalConfigInit, HelpGroups, InferArgs, InferFlags, JsonParser, ListrLogger, LockData, LockableData, LockerService, LogFieldStatus, LogLevels, Logger, LoggerFormat, LoggerOptions, MergeStrategy, ParserService, PipeProcessToLoggerOptions, SetCtxAssignOptions, SetCtxDefaultsOptions, UnlockData, ValidatorService, ValidatorServiceOptions, Winston, YamlParser, color, isDebug, isSilent, isVerbose, merge, pipeProcessThroughListr, pipeProcessToLogger, setCtxAssign, setCtxDefaults, setup };
+export { CLI_FLAGS, ClassType, Command, CommonLockerData, ConfigCommand, ConfigCommandChoices, ConfigCommandSetup, ConfigIterator, ConfigService, DeepPartial, EnvironmentVariableParser, FileConstants, FileSystemService, GenericParser, GlobalConfig, GlobalConfigInit, HelpGroups, InferArgs, InferFlags, JsonParser, ListrLogger, LockData, LockableData, LockerService, LogFieldStatus, LogLevels, Logger, LoggerFormat, LoggerOptions, MergeStrategy, ParserService, PipeProcessToLoggerOptions, SetCtxAssignOptions, SetCtxDefaultsOptions, UnlockData, ValidatorService, ValidatorServiceOptions, Winston, YamlParser, color, isDebug, isSilent, isVerbose, merge, pipeProcessThroughListr, pipeProcessToLogger, setCtxAssign, setCtxDefaults, setup, uniqueFilter };