4.0.0

package-lock.json

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

package.json

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

test/test.ts

@@ -4,28 +4,30 @@ import * as qenv from '../ts/index';
 
 process.env['key1'] = 'original';
 
-let qenvTestObject: qenv.Qenv;
+let testQenv: qenv.Qenv;
 
 tap.test('should create a new class', async () => {
-  qenvTestObject = new qenv.Qenv(
+  testQenv = new qenv.Qenv(
     path.join(__dirname, 'assets'),
     path.join(__dirname, 'assets'),
     false
   );
-  expect(qenvTestObject).to.be.instanceof(qenv.Qenv);
+  expect(testQenv).to.be.instanceof(qenv.Qenv);
 });
 
 tap.test('key1 should be not be overwritten since it is already present', async () => {
-  expect(process.env.key1).to.equal('original');
+  expect(testQenv.getEnvVarRequired('key1')).to.equal('original');
+  expect(testQenv.getEnvVarOnDemand('key1')).to.equal('original');
 });
 
 tap.test('key2 should be read from Yml', async () => {
-  expect(process.env.key2).to.equal('fromYml');
+  expect(testQenv.getEnvVarRequired('key2')).to.equal('fromYml');
+  expect(testQenv.getEnvVarOnDemand('key2')).to.equal('fromYml');
 });
 
 tap.test('keyValueObjectArray should hold all retrieved values', async () => {
-  expect(qenvTestObject.keyValueObjectArray[0].value).to.equal('original');
+  expect(testQenv.keyValueObject.key1).to.equal('original');
-  expect(qenvTestObject.keyValueObjectArray[1].value).to.equal('fromYml');
+  expect(testQenv.keyValueObject.key2).to.equal('fromYml');
 });
 
 tap.start();

ts/qenv.classes.qenv.ts

@@ -1,15 +1,15 @@
 import * as plugins from './qenv.plugins';
+plugins.smartlog.defaultLogger.enableConsole();
 
-export interface IKeyValueObject {
+/**
-  key: string;
+ * class Qenv
-  value: string;
+ * 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[] = [];
   public missingEnvVars: string[] = [];
-  public keyValueObjectArray: IKeyValueObject[] = [];
+  public keyValueObject: {[key: string]: any } = {};
   public logger: plugins.smartlog.Smartlog;
 
   // filePaths
@@ -25,8 +25,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.qenvFilePathAbsolute = plugins.path.join(
-    this.envFilePathAbsolute = plugins.path.join(plugins.path.resolve(envFileBasePathArg), 'env.yml');
+      plugins.path.resolve(qenvFileBasePathArg),
+      'qenv.yml'
+    );
+    this.envFilePathAbsolute = plugins.path.join(
+      plugins.path.resolve(envFileBasePathArg),
+      'env.yml'
+    );
 
     this.getRequiredEnvVars();
     this.getAvailableEnvVars();
@@ -46,87 +52,123 @@ export class Qenv {
     }
   }
 
-  public getEnvVar(envVarName): string {
+  /**
-    return process.env[envVarName];
+   * only gets an environment variable if it is required within a read qenv.yml file
+   * @param envVarName
+   */
+  public getEnvVarRequired(envVarName): string {
+    return this.keyValueObject[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 envFileVar: string;
-      let dockerSecret: string;
+    let dockerSecret: string;
+    let dockerSecretJson: string;
 
-      // env var check
+    // env var check
-      if (process.env[requiredEnvVar]) {
+    if (process.env[requiredEnvVar]) {
-        this.availableEnvVars.push(requiredEnvVar);
+      this.availableEnvVars.push(requiredEnvVar);
-        envVar = process.env[requiredEnvVar];
+      envVar = process.env[requiredEnvVar];
-      }
+    }
 
-      // env file check
+    // env file check
-      if (envYml.hasOwnProperty(requiredEnvVar)) {
+    if (envYml.hasOwnProperty(requiredEnvVar)) {
-        envFileVar = envYml[requiredEnvVar];
+      envFileVar = envYml[requiredEnvVar];
-        this.availableEnvVars.push(requiredEnvVar);
+      this.availableEnvVars.push(requiredEnvVar);
-      }
+    }
-      if (
-        plugins.smartfile.fs.isDirectory('/run') &&
-        plugins.smartfile.fs.isDirectory('/run/secrets') &&
-        plugins.smartfile.fs.fileExists(`/run/secrets/${requiredEnvVar}`)
-      ) {
-        dockerSecret = plugins.smartfile.fs.toStringSync(`/run/secrets/${requiredEnvVar}`);
-      }
 
-      if ((envVar && envFileVar) || (envVar && dockerSecret) || (envFileVar && dockerSecret)) {
+    // docker secret check
-        this.logger.log(
+    if (
-          'warn',
+      plugins.smartfile.fs.isDirectory('/run') &&
-          `found multiple candidates for ${requiredEnvVar} Choosing in the order of envVar, envFileVar, dockerSecret`
+      plugins.smartfile.fs.isDirectory('/run/secrets') &&
-        );
+      plugins.smartfile.fs.fileExistsSync(`/run/secrets/${requiredEnvVar}`)
-      }
+    ) {
+      dockerSecret = plugins.smartfile.fs.toStringSync(`/run/secrets/${requiredEnvVar}`);
+    }
 
-      let chosenVar: string = null;
+    // docker secret.json
-      if (envVar) {
+    if (
-        chosenVar = envVar;
+      plugins.smartfile.fs.isDirectory('/run') &&
-      } else if (envFileVar) {
+      plugins.smartfile.fs.isDirectory('/run/secrets')
-        chosenVar = envFileVar;
+    ) {
-      } else if (dockerSecret) {
+      const availableSecrets = plugins.smartfile.fs.listAllItemsSync('/run/secrets');
-        chosenVar = dockerSecret;
+      for (const secret of availableSecrets) {
+        if (secret.includes('secret.json') && !dockerSecret) {
+          const secretObject = plugins.smartfile.fs.toObjectSync(`/run/secrets/${secret}`);
+          dockerSecret = secretObject[requiredEnvVar];
+        }
       }
-      return chosenVar;
+    }
+
+    // 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, 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;
   }
 
   /**
    * gets the required env values
    */
   private getRequiredEnvVars = () => {
-    const qenvFile = plugins.smartfile.fs.toObjectSync(this.qenvFilePathAbsolute);
+    let qenvFile: any = {};
-    if (!qenvFile.required) {
+    if (plugins.smartfile.fs.fileExistsSync(this.qenvFilePathAbsolute)) {
+      qenvFile = plugins.smartfile.fs.toObjectSync(this.qenvFilePathAbsolute);
+    }
+    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]);
+      }
     }
-    for (const keyArg of Reflect.ownKeys(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) {
         this.availableEnvVars.push(requiredEnvVar);
-        process.env[requiredEnvVar] = chosenVar;
+        this.keyValueObject[requiredEnvVar] = chosenVar;
-        this.keyValueObjectArray.push({
-          key: requiredEnvVar,
-          value: chosenVar
-        });
       }
     }
   }
@@ -142,5 +184,5 @@ export class Qenv {
       }
     }
     return missingEnvVars;
-  }
+  };
 }