@cenk1cenk2/oclif-common 3.0.3 → 3.1.0-beta.10

package/dist/index.d.ts

@@ -98,13 +98,21 @@ interface PipeProcessToLoggerOptions {
  */
 declare function pipeProcessToLogger(logger: Logger, instance: ExecaChildProcess, options?: PipeProcessToLoggerOptions): ExecaChildProcess;
 
-interface GlobalConfig {
+interface GlobalConfigInit {
     logLevel: LogLevels;
     ci: boolean;
+    json: boolean;
+}
+interface GlobalConfig extends GlobalConfigInit {
     isVerbose: boolean;
     isDebug: boolean;
     isSilent: boolean;
-    json: boolean;
+}
+interface ConfigIterator {
+    key: (string | number)[];
+    env: string;
+    parser?: string;
+    extensions?: ConfigIterator[];
 }
 
 declare const color: colorette.Colorette;
@@ -203,9 +211,9 @@ declare class ConfigService implements GlobalConfig {
     private readonly logger;
     constructor(oclif: Command['config'], command: Command['ctor'], config: Omit<GlobalConfig, 'isVerbose' | 'isDebug' | 'isSilent'>);
     read<T extends LockableData = LockableData>(path: string): Promise<T>;
-    extend<T extends LockableData = LockableData>(paths: string[], strategy?: MergeStrategy): Promise<T>;
-    merge<T extends LockableData = LockableData>(configs: Partial<T>[], strategy?: MergeStrategy): Promise<T>;
-    env<T extends LockableData = LockableData>(definition: string, config: T): Promise<T>;
+    extend<T extends LockableData = LockableData>(paths: (string | Partial<T>)[], strategy?: MergeStrategy): Promise<T>;
+    merge<T extends LockableData = LockableData>(configs: Partial<T>[], strategy?: MergeStrategy): T;
+    env<T extends LockableData = LockableData>(definition: string | Record<PropertyKey, any>, config: T): Promise<T>;
     write<T extends LockableData = LockableData>(path: string, data: T): Promise<void>;
     private recalculate;
 }
@@ -275,6 +283,13 @@ interface ConfigCommandSetup<T extends string = string, LockFile = any> {
 declare type InferFlags<T extends typeof Command$1> = InferredFlags<T['globalFlags'] & T['flags']>;
 declare type InferArgs<T extends typeof Command$1> = Record<T['args'][number]['name'], string>;
 
+/**
+ * Makes the object deep partial.
+ */
+declare type DeepPartial<T> = {
+    [P in keyof T]?: DeepPartial<T[P]>;
+};
+
 declare abstract 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 {
     static globalFlags: {
         "log-level": _oclif_core_lib_interfaces.OptionFlag<string>;
@@ -364,4 +379,4 @@ declare const _default: {
     };
 };
 
-export { ClassType, Command, CommonLockerData, ConfigCommand, ConfigCommandChoices, ConfigCommandSetup, ConfigService, FileConstants, FileSystemService, GenericParser, GlobalConfig, HelpGroups, InferArgs, InferFlags, JsonParser, LockData, LockableData, LockerService, LogFieldStatus, LogLevels, Logger, LoggerFormat, LoggerOptions, MergeStrategy, ParserService, PipeProcessToLoggerOptions, SetCtxAssignOptions, SetCtxDefaultsOptions, UnlockData, ValidatorService, ValidatorServiceOptions, Winston, YamlParser, color, _default as default, isDebug, isSilent, isVerbose, merge, pipeProcessThroughListr, pipeProcessToLogger, setCtxAssign, setCtxDefaults, setup };
+export { ClassType, Command, CommonLockerData, ConfigCommand, ConfigCommandChoices, ConfigCommandSetup, ConfigIterator, ConfigService, DeepPartial, FileConstants, FileSystemService, GenericParser, GlobalConfig, GlobalConfigInit, HelpGroups, InferArgs, InferFlags, JsonParser, LockData, LockableData, LockerService, LogFieldStatus, LogLevels, Logger, LoggerFormat, LoggerOptions, MergeStrategy, ParserService, PipeProcessToLoggerOptions, SetCtxAssignOptions, SetCtxDefaultsOptions, UnlockData, ValidatorService, ValidatorServiceOptions, Winston, YamlParser, color, _default as default, isDebug, isSilent, isVerbose, merge, pipeProcessThroughListr, pipeProcessToLogger, setCtxAssign, setCtxDefaults, setup };

package/dist/index.js

@@ -617,11 +617,11 @@ var ConfigService = class {
     return config;
   }
   async extend(paths, strategy = "OVERWRITE" /* OVERWRITE */) {
-    this.logger.trace("Will generate config from: %s with %s", paths.join(", "), strategy);
+    this.logger.trace("Will generate config from: %o with %s", paths, strategy);
     const configs = (await Promise.all(
       paths.map(async (path) => {
         try {
-          const config = await this.parser.read(path);
+          const config = typeof path === "string" ? await this.parser.read(path) : path;
           this.logger.trace("Extending config from: %s", path);
           return config;
         } catch (e) {
@@ -631,15 +631,15 @@ var ConfigService = class {
     )).filter(Boolean);
     return this.merge(configs, strategy);
   }
-  async merge(configs, strategy = "OVERWRITE" /* OVERWRITE */) {
+  merge(configs, strategy = "OVERWRITE" /* OVERWRITE */) {
     if (configs.length === 0) {
       throw new Error("Nothing to merge, configuration files are empty.");
     }
     return merge(strategy, configs.some((config) => Array.isArray(config)) ? [] : {}, ...configs);
   }
   async env(definition, config) {
-    const env = await this.parser.read(definition);
-    this.logger.trace("Environment variable extensions read: %s", definition);
+    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]) => {
@@ -647,41 +647,76 @@ var ConfigService = class {
           if (typeof value === "string") {
             return [{ key: location, env: value }];
           } else if (typeof value === "object") {
-            if ("__name" in value && "__format" in value) {
-              return [
+            let extensions;
+            if ("__element" /* ELEMENT */ in value) {
+              this.logger.trace("Expanding location to elements: %s", location);
+              extensions = await iter(value["__element" /* ELEMENT */], [...location, "__element" /* ELEMENT */]);
+            }
+            if ("__name" /* NAME */ in value && "__format" /* PARSER */ in value) {
+              const variable = [
                 {
                   key: location,
-                  env: value.__name,
-                  parser: value.__format
+                  env: value["__name" /* NAME */],
+                  parser: value["__format" /* PARSER */],
+                  extensions
                 }
               ];
+              return variable;
             } else {
               return iter(value, location);
             }
           }
         })
       );
-      return data.flatMap((d) => d);
+      return data.flatMap((d) => d).filter(Boolean);
     }, "iter");
     const parsed = await iter(env);
+    const cb = /* @__PURE__ */ __name(async (config2, variable, data) => {
+      if (variable.parser) {
+        try {
+          data = await 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");
     await Promise.all(
       parsed.map(async (variable) => {
-        let data = process.env[variable.env];
-        if (!data) {
-          return;
+        let data;
+        data = process.env[variable.env];
+        if (data) {
+          config = await cb(config, variable, data);
         }
-        if (variable.parser) {
-          try {
-            data = await this.parser.parse(variable.parser, data);
-          } catch (e) {
-            this.logger.trace("Can not parse environment variable for config: %s -> %s with %s", variable.key.join("."), variable.env, variable.parser);
-            throw e;
+        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 = (await Promise.all(
+              variable.extensions.map(async (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;
+                data = process.env[clone.env];
+                if (!data) {
+                  this.logger.trace("No extension for environment variable: %s -> %s", clone.key.join("."), clone.env);
+                  return;
+                }
+                return cb({}, clone, data);
+              })
+            )).filter(Boolean);
+            if (extensions.length === 0) {
+              this.logger.trace("No more extensions for environment variables: %s -> %d", variable.key.join("."), i);
+              break;
+            }
+            config = this.merge([config, ...extensions], "EXTEND" /* EXTEND */);
           }
         }
-        config = import_object_path_immutable.default.update(config, variable.key, () => {
-          this.logger.trace("Overwriting config with environment variable: %s -> %s", variable.key.join("."), variable.env);
-          return data;
-        });
       })
     );
     return config;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cenk1cenk2/oclif-common",
-  "version": "3.0.3",
+  "version": "3.1.0-beta.10",
   "description": "Oclif common package for oclif2 projects.",
   "repository": "https://gitlab.kilic.dev/libraries/oclif-tools",
   "author": {