3.1.0

package-lock.json

@@ -1,6 +1,6 @@
 {
   "name": "@pushrocks/qenv",
-  "version": "3.0.0",
+  "version": "3.1.0",
   "lockfileVersion": 1,
   "requires": true,
   "dependencies": {

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pushrocks/qenv",
-  "version": "3.0.0",
+  "version": "3.1.0",
   "private": false,
   "description": "easy promised environments",
   "main": "dist/index.js",

test/test.ts

@@ -17,10 +17,12 @@ tap.test('should create a new class', async () => {
 
 tap.test('key1 should be not be overwritten since it is already present', async () => {
   expect(process.env.key1).to.equal('original');
+  expect(qenvTestObject.getEnvVarOnDemand('key1')).to.equal('original');
 });
 
 tap.test('key2 should be read from Yml', async () => {
   expect(process.env.key2).to.equal('fromYml');
+  expect(qenvTestObject.getEnvVarOnDemand('key2')).to.equal('fromYml');
 });
 
 tap.test('keyValueObjectArray should hold all retrieved values', async () => {

ts/qenv.classes.qenv.ts

@@ -1,10 +1,15 @@
 import * as plugins from './qenv.plugins';
+plugins.smartlog.defaultLogger.enableConsole();
 
 export interface IKeyValueObject {
   key: string;
   value: string;
 }
 
+/**
+ * class Qenv
+ * allows to make assertions about the environments while being more flexibel in how to meet them
+ */
 export class Qenv {
   public requiredEnvVars: string[] = [];
   public availableEnvVars: string[] = [];
@@ -25,8 +30,14 @@ export class Qenv {
     this.logger = loggerArg;
 
     // lets make sure paths are absolute
-    this.qenvFilePathAbsolute = plugins.path.join(plugins.path.resolve(qenvFileBasePathArg), 'qenv.yml');
-    this.envFilePathAbsolute = plugins.path.join(plugins.path.resolve(envFileBasePathArg), 'env.yml');
+    this.qenvFilePathAbsolute = plugins.path.join(
+      plugins.path.resolve(qenvFileBasePathArg),
+      'qenv.yml'
+    );
+    this.envFilePathAbsolute = plugins.path.join(
+      plugins.path.resolve(envFileBasePathArg),
+      'env.yml'
+    );
 
     this.getRequiredEnvVars();
     this.getAvailableEnvVars();
@@ -46,22 +57,30 @@ export class Qenv {
     }
   }
 
-  public getEnvVar(envVarName): string {
+  /**
+   * only gets an environment variable if it is required within a read qenv.yml file
+   * @param envVarName
+   */
+  public getEnvVarRequired(envVarName): string {
     return process.env[envVarName];
   }
 
+  /**
+   * tries to get any env var even if it is not required
+   * @param requiredEnvVar
+   */
   public getEnvVarOnDemand(requiredEnvVar: string): string {
     // lets determine the actual env yml
     let envYml;
     try {
       envYml = plugins.smartfile.fs.toObjectSync(this.envFilePathAbsolute);
     } catch (err) {
-      console.log("env file couldn't be found at " + this.envFilePathAbsolute);
       envYml = {};
     }
     let envVar: string;
     let envFileVar: string;
     let dockerSecret: string;
+    let dockerSecretJson: string;
 
     // env var check
     if (process.env[requiredEnvVar]) {
@@ -74,28 +93,57 @@ export class Qenv {
       envFileVar = envYml[requiredEnvVar];
       this.availableEnvVars.push(requiredEnvVar);
     }
+
+    // docker secret check
     if (
       plugins.smartfile.fs.isDirectory('/run') &&
       plugins.smartfile.fs.isDirectory('/run/secrets') &&
-        plugins.smartfile.fs.fileExists(`/run/secrets/${requiredEnvVar}`)
+      plugins.smartfile.fs.fileExistsSync(`/run/secrets/${requiredEnvVar}`)
     ) {
       dockerSecret = plugins.smartfile.fs.toStringSync(`/run/secrets/${requiredEnvVar}`);
     }
 
-      if ((envVar && envFileVar) || (envVar && dockerSecret) || (envFileVar && dockerSecret)) {
+    // docker secret.json
+    if (
+      plugins.smartfile.fs.isDirectory('/run') &&
+      plugins.smartfile.fs.isDirectory('/run/secrets')
+    ) {
+      const availableSecrets = plugins.smartfile.fs.listAllItemsSync('/run/secrets');
+      for (const secret of availableSecrets) {
+        if (secret.includes('secret.json') && !dockerSecret) {
+          const secretObject = plugins.smartfile.fs.toObjectSync('/run/secrets/secret.json');
+          dockerSecret = secretObject[requiredEnvVar];
+        }
+      }
+    }
+
+    // warn if there is more than one candidate
+    let candidatesCounter = 0;
+    [envVar, envFileVar, dockerSecret, dockerSecretJson].forEach(candidate => {
+      if (candidate) {
+        candidatesCounter++;
+      }
+    });
+    if (candidatesCounter > 1) {
       this.logger.log(
         'warn',
-          `found multiple candidates for ${requiredEnvVar} Choosing in the order of envVar, envFileVar, dockerSecret`
+        `found multiple candidates for ${requiredEnvVar} Choosing in the order of envVar, envFileVar, dockerSecret, dockerSecretJson`
       );
     }
 
     let chosenVar: string = null;
     if (envVar) {
+      this.logger.log('ok', `found ${requiredEnvVar} as environment variable`);
       chosenVar = envVar;
     } else if (envFileVar) {
+      this.logger.log('ok', `found ${requiredEnvVar} as env.yml variable`);
       chosenVar = envFileVar;
     } else if (dockerSecret) {
+      this.logger.log('ok', `found ${requiredEnvVar} as docker secret`);
       chosenVar = dockerSecret;
+    } else if (dockerSecretJson) {
+      this.logger.log('ok', `found ${requiredEnvVar} as docker secret.json`);
+      chosenVar = dockerSecretJson;
     }
     return chosenVar;
   }
@@ -104,20 +152,23 @@ export class Qenv {
    * gets the required env values
    */
   private getRequiredEnvVars = () => {
-    const qenvFile = plugins.smartfile.fs.toObjectSync(this.qenvFilePathAbsolute);
-    if (!qenvFile.required) {
-      this.logger.log('warn', `env File does not contain a 'required' Array!`);
+    let qenvFile: any = {};
+    if (plugins.smartfile.fs.fileExistsSync(this.qenvFilePathAbsolute)) {
+      qenvFile = plugins.smartfile.fs.toObjectSync(this.qenvFilePathAbsolute);
     }
-    for (const keyArg of Reflect.ownKeys(qenvFile.required)) {
+    if (!qenvFile || !qenvFile.required || !Array.isArray(qenvFile.required)) {
+      this.logger.log('warn', `env File does not contain a 'required' Array!`);
+    } else {
+      for (const keyArg of Object.keys(qenvFile.required)) {
         this.requiredEnvVars.push(qenvFile.required[keyArg]);
       }
     }
+  };
 
   /**
    * gets the available env vars
    */
   private getAvailableEnvVars = () => {
-
     for (const requiredEnvVar of this.requiredEnvVars) {
       const chosenVar = this.getEnvVarOnDemand(requiredEnvVar);
       if (chosenVar) {
@@ -129,7 +180,7 @@ export class Qenv {
         });
       }
     }
-  }
+  };
 
   /**
    * gets missing env vars
@@ -142,5 +193,5 @@ export class Qenv {
       }
     }
     return missingEnvVars;
-  }
+  };
 }