@cenk1cenk2/oclif-common 3.1.0-beta.7 → 3.1.0

package/dist/index.d.ts

@@ -112,6 +112,7 @@ interface ConfigIterator {
     key: (string | number)[];
     env: string;
     parser?: string;
+    extensions?: ConfigIterator[];
 }
 
 declare const color: colorette.Colorette;
@@ -152,8 +153,8 @@ interface UnlockData extends CommonLockerData {
 
 declare class GenericParser {
     static extensions: string[];
-    parse<T = unknown>(data: string | Buffer): T | Promise<T>;
-    stringify<T = any>(data: T): string | Promise<string>;
+    parse<T = unknown>(data: string | Buffer): T;
+    stringify<T = any>(data: T): string;
 }
 
 declare class LockerService<LockFile extends LockableData = LockableData> {
@@ -190,7 +191,7 @@ declare class ParserService {
     addParsers(...parsers: ClassType<GenericParser>[]): void;
     read<T = unknown>(file: string): Promise<T>;
     write<T = LockableData>(file: string, data: T): Promise<void>;
-    parse<T = unknown>(file: string, data: string | Buffer): T | Promise<T>;
+    parse<T = unknown>(file: string, data: string | Buffer): T;
     stringify<T = any>(file: string, data: T): string | Promise<string>;
 }
 
@@ -212,7 +213,7 @@ declare class ConfigService implements GlobalConfig {
     read<T extends LockableData = LockableData>(path: string): 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 | T, config: T): Promise<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;
 }

package/dist/index.js

@@ -647,19 +647,19 @@ var ConfigService = class {
           if (typeof value === "string") {
             return [{ key: location, env: value }];
           } else if (typeof value === "object") {
-            const extras = [];
+            let extensions;
             if ("__element" /* ELEMENT */ in value) {
-              this.logger.trace("Expanding location to elements: %s", location);
-              extras.push(...await iter(value["__element" /* ELEMENT */], [...location, "__element" /* ELEMENT */]));
+              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 */]
-                },
-                ...extras
+                  parser: value["__format" /* PARSER */],
+                  extensions
+                }
               ];
               return variable;
             } else {
@@ -671,51 +671,50 @@ var ConfigService = class {
       return data.flatMap((d) => d).filter(Boolean);
     }, "iter");
     const parsed = await iter(env);
-    this.logger.trace("Environment variable injection: %o", parsed);
-    const cb = /* @__PURE__ */ __name(async (variable, data) => {
+    const cb = /* @__PURE__ */ __name((config2, variable, data) => {
       if (variable.parser) {
         try {
-          variable = await this.parser.parse(variable.parser, data);
+          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;
         }
       }
-      return 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 variable;
-      });
+      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;
-        if (variable.key?.includes("__element" /* ELEMENT */)) {
-          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 clone = JSON.parse(JSON.stringify(variable));
+    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());
-            this.logger.trace("Looking for environment variable element: %o", clone);
+            clone.key[clone.key.findIndex((value) => value === "__element" /* ELEMENT */)] = i.toString();
             data = process.env[clone.env];
             if (!data) {
-              this.logger.trace("No more variable available: %s -> %d", variable.env, i);
-              break;
+              this.logger.trace("No extension for environment variable: %s -> %s", clone.key.join("."), clone.env);
+              return;
             }
-            clone.key[clone.key.findIndex((value) => value === "__element" /* ELEMENT */)] = i;
-            config = await cb(clone, data);
+            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;
         }
-        data = process.env[variable.env];
-        if (!data) {
-          return;
-        }
-        config = await cb(variable, data);
-      })
-    );
+      }
+    });
     return config;
   }
   async write(path, data) {
@@ -820,7 +819,7 @@ var LockerService = class {
     return this.parser.parse(await this.fs.read(this.file));
   }
   async write(data) {
-    return this.fs.write(this.file, await this.parser.stringify(data));
+    return this.fs.write(this.file, this.parser.stringify(data));
   }
   buildPath(d) {
     if (d?.root !== true && this.root) {

package/package.json

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