6.0.2

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@push.rocks/qenv",
-  "version": "5.0.5",
+  "version": "6.0.2",
   "private": false,
   "description": "easy promised environments",
   "main": "dist_ts/index.js",
@@ -34,6 +34,7 @@
     "@types/node": "^20.4.6"
   },
   "dependencies": {
+    "@api.global/typedrequest": "^3.0.1",
     "@configvault.io/interfaces": "^1.0.2",
     "@push.rocks/smartfile": "^10.0.28",
     "@push.rocks/smartlog": "^3.0.3",

test/test.ts

@@ -18,18 +18,18 @@ tap.test('should create a new class', async () => {
 });
 
 tap.test('key1 should be not be overwritten since it is already present', async () => {
-  expect(testQenv.getEnvVarOnDemand('key1')).toEqual('original');
+  expect(await testQenv.getEnvVarOnDemand('key1')).toEqual('original');
-  expect(testQenv.getEnvVarOnDemand('key1')).toEqual('original');
+  expect(await testQenv.getEnvVarOnDemand('key1')).toEqual('original');
 });
 
 tap.test('key2 should be read from Yml', async () => {
-  expect(testQenv.getEnvVarOnDemand('key2')).toEqual('fromJson');
+  expect(await testQenv.getEnvVarOnDemand('key2')).toEqual('fromJson');
-  expect(testQenv.getEnvVarOnDemand('key2')).toEqual('fromJson');
+  expect(await testQenv.getEnvVarOnDemand('key2')).toEqual('fromJson');
 });
 
 tap.test('keyValueObjectArray should hold all retrieved values', async () => {
-  expect(testQenv.keyValueObject.key1).toEqual('original');
+  expect(await testQenv.keyValueObject.key1).toEqual('original');
-  expect(testQenv.keyValueObject.key2).toEqual('fromJson');
+  expect(await testQenv.keyValueObject.key2).toEqual('fromJson');
 });
 
 tap.start();

ts/00_commitinfo_data.ts

@@ -3,6 +3,6 @@
  */
 export const commitinfo = {
   name: '@push.rocks/qenv',
-  version: '5.0.5',
+  version: '6.0.2',
   description: 'easy promised environments'
 }

ts/qenv.classes.configvaultadapter.ts

@@ -0,0 +1,30 @@
+import * as plugins from './qenv.plugins.js';
+
+export class ConfigVaultAdapter {
+  public configVaultUrl: string;
+  
+  constructor(configVaultUrl?: string) {
+    this.configVaultUrl = configVaultUrl;
+  }
+
+  public async getConfigBundle(): Promise<plugins.configvaultInterfaces.data.IConfigBundle> {
+    if (this.configVaultUrl) {
+      console.log(`ConfigVault specified through constructor`)
+    } else if (process.env['CONFIGVAULT_URL']) {
+      this.configVaultUrl = process.env['CONFIGVAULT_URL'];
+    } else {
+      return null;
+    }
+
+    const parsedUrl = new URL(this.configVaultUrl);
+
+    const tr =
+      new plugins.typedrequest.TypedRequest<plugins.configvaultInterfaces.requests.IReq_GetConfigBundle>(
+        `${parsedUrl.host}/typedrequest`,
+        'getConfigBundle'
+      );
+    const response = await tr.fire({
+      authorization: parsedUrl.pathname.replace('/', ''),
+    })
+  }
+}

ts/qenv.classes.qenv.ts

@@ -1,3 +1,4 @@
+import { ConfigVaultAdapter } from './qenv.classes.configvaultadapter.js';
 import * as plugins from './qenv.plugins.js';
 
 export class Qenv {
@@ -7,6 +8,8 @@ export class Qenv {
   public keyValueObject: { [key: string]: any } = {};
   public logger = new plugins.smartlog.ConsoleLog();
 
+  public configVaultAdapter: ConfigVaultAdapter;
+
   public qenvFilePathAbsolute: string;
   public envFilePathAbsolute: string;
 
@@ -15,6 +18,7 @@ export class Qenv {
     envFileBasePathArg: string,
     failOnMissing: boolean = true
   ) {
+    this.configVaultAdapter = new ConfigVaultAdapter();
     this.initializeFilePaths(qenvFileBasePathArg, envFileBasePathArg);
     this.loadRequiredEnvVars();
     this.loadAvailableEnvVars();
@@ -22,8 +26,14 @@ export class Qenv {
   }
 
   private initializeFilePaths(qenvFileBasePathArg: string, envFileBasePathArg: string) {
-    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.json');
+      plugins.path.resolve(qenvFileBasePathArg),
+      'qenv.yml'
+    );
+    this.envFilePathAbsolute = plugins.path.join(
+      plugins.path.resolve(envFileBasePathArg),
+      'env.json'
+    );
   }
 
   private loadRequiredEnvVars() {
@@ -48,7 +58,9 @@ export class Qenv {
   }
 
   private checkForMissingEnvVars(failOnMissing: boolean) {
-    this.missingEnvVars = this.requiredEnvVars.filter((envVar) => !this.availableEnvVars.includes(envVar));
+    this.missingEnvVars = this.requiredEnvVars.filter(
+      (envVar) => !this.availableEnvVars.includes(envVar)
+    );
 
     if (this.missingEnvVars.length > 0) {
       console.info('Required Env Vars are:', this.requiredEnvVars);
@@ -62,7 +74,48 @@ export class Qenv {
     }
   }
 
-  public getEnvVarOnDemand(envVarName: string): string | undefined {
+  public async getEnvVarOnDemand(
+    envVarNameOrNames: string | string[]
+  ): Promise<string | undefined> {
+    if (Array.isArray(envVarNameOrNames)) {
+      for (const envVarName of envVarNameOrNames) {
+        const value = await this.tryGetEnvVar(envVarName);
+        if (value) {
+          return value;
+        }
+      }
+      return undefined;
+    } else {
+      return await this.tryGetEnvVar(envVarNameOrNames);
+    }
+  }
+
+  public getEnvVarOnDemandSync(envVarNameOrNames: string | string[]): string | undefined {
+    console.warn('requesting env var sync leaves out potentially important async env sources.');
+
+    if (Array.isArray(envVarNameOrNames)) {
+      for (const envVarName of envVarNameOrNames) {
+        const value = this.tryGetEnvVarSync(envVarName);
+        if (value) {
+          return value;
+        }
+      }
+      return undefined;
+    } else {
+      return this.tryGetEnvVarSync(envVarNameOrNames);
+    }
+  }
+
+  public async getEnvVarOnDemandAsObject(envVarNameOrNames: string | string[]): Promise<any> {
+    const rawValue = await this.getEnvVarOnDemand(envVarNameOrNames);
+    if (rawValue && rawValue.startsWith('base64Object:')) {
+      const base64Part = rawValue.split('base64Object:')[1];
+      return this.decodeBase64(base64Part);
+    }
+    return rawValue;
+  }
+
+  private async tryGetEnvVar(envVarName: string): Promise<string | undefined> {
     return (
       this.getFromEnvironmentVariable(envVarName) ||
       this.getFromEnvJsonFile(envVarName) ||
@@ -71,13 +124,13 @@ export class Qenv {
     );
   }
 
-  public getEnvVarOnDemandAsObject(envVarName: string): any {
+  private tryGetEnvVarSync(envVarName: string): string | undefined {
-    const rawValue = this.getEnvVarOnDemand(envVarName);
+    return (
-    if (rawValue && rawValue.startsWith('base64Object:')) {
+      this.getFromEnvironmentVariable(envVarName) ||
-      const base64Part = rawValue.split('base64Object:')[1];
+      this.getFromEnvJsonFile(envVarName) ||
-      return this.decodeBase64(base64Part);
+      this.getFromDockerSecret(envVarName) ||
-    }
+      this.getFromDockerSecretJson(envVarName)
-    return rawValue;
+    );
   }
 
   private getFromEnvironmentVariable(envVarName: string): string | undefined {

ts/qenv.plugins.ts

@@ -3,8 +3,20 @@ import * as path from 'path';
 
 export { path };
 
+// @api.global scope
+import * as typedrequest from '@api.global/typedrequest';
+
+export {
+  typedrequest,
+}
+
 // @pushrocks scope
 import * as smartfile from '@push.rocks/smartfile';
 import * as smartlog from '@push.rocks/smartlog';
 
 export { smartfile, smartlog };
+
+// @configvault.io scope
+import * as configvaultInterfaces from '@configvault.io/interfaces';
+
+export { configvaultInterfaces };