6.0.5

.gitea/workflows/default_tags.yaml

@@ -119,6 +119,6 @@ jobs:
         run: |
           npmci node install stable
           npmci npm install
-          pnpm install -g @gitzone/tsdoc
+          pnpm install -g @git.zone/tsdoc
           npmci command tsdoc
         continue-on-error: true

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@push.rocks/qenv",
-  "version": "5.0.3",
+  "version": "6.0.5",
   "private": false,
   "description": "easy promised environments",
   "main": "dist_ts/index.js",
@@ -27,15 +27,16 @@
   },
   "homepage": "https://gitlab.com/pushrocks/qenv#README",
   "devDependencies": {
-    "@gitzone/tsbuild": "^2.1.66",
+    "@git.zone/tsbuild": "^2.1.72",
-    "@gitzone/tsrun": "^1.2.44",
+    "@git.zone/tsrun": "^1.2.44",
-    "@gitzone/tstest": "^1.0.77",
+    "@git.zone/tstest": "^1.0.86",
-    "@push.rocks/tapbundle": "^5.0.12",
+    "@push.rocks/tapbundle": "^5.0.15",
-    "@types/node": "^20.4.6"
+    "@types/node": "^20.11.17"
   },
   "dependencies": {
-    "@configvault.io/interfaces": "^1.0.2",
+    "@api.global/typedrequest": "^3.0.4",
-    "@push.rocks/smartfile": "^10.0.28",
+    "@configvault.io/interfaces": "^1.0.17",
+    "@push.rocks/smartfile": "^11.0.4",
     "@push.rocks/smartlog": "^3.0.3",
     "@push.rocks/smartpath": "^5.0.11"
   },

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.getEnvVarRequired('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.getEnvVarRequired('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.3',
+  version: '6.0.5',
   description: 'easy promised environments'
 }

ts/qenv.classes.configvaultadapter.ts

@@ -0,0 +1,30 @@
+import * as plugins from './qenv.plugins.js';
+
+export class CloudlyAdapter {
+  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_GetEnvBundle>(
+        `${parsedUrl.host}/typedrequest`,
+        'getEnvBundle'
+      );
+    const response = await tr.fire({
+      authorization: parsedUrl.pathname.replace('/', ''),
+    })
+  }
+}

ts/qenv.classes.qenv.ts

@@ -1,9 +1,8 @@
+import { CloudlyAdapter } from './qenv.classes.configvaultadapter.js';
 import * as plugins from './qenv.plugins.js';
 
-/**
+export type TEnvVarRef = string | (() => Promise<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[] = [];
@@ -11,34 +10,67 @@ export class Qenv {
   public keyValueObject: { [key: string]: any } = {};
   public logger = new plugins.smartlog.ConsoleLog();
 
-  // filePaths
+  public cloudlyAdapter: CloudlyAdapter;
+
   public qenvFilePathAbsolute: string;
   public envFilePathAbsolute: string;
 
-  constructor(qenvFileBasePathArg = process.cwd(), envFileBasePathArg, failOnMissing = true) {
+  constructor(
-    // lets make sure paths are absolute
+    qenvFileBasePathArg: string = process.cwd(),
+    envFileBasePathArg?: string,
+    failOnMissing: boolean = true
+  ) {
+    this.cloudlyAdapter = new CloudlyAdapter();
+    this.initializeFilePaths(qenvFileBasePathArg, envFileBasePathArg);
+    this.loadRequiredEnvVars();
+    this.loadAvailableEnvVars();
+    this.checkForMissingEnvVars(failOnMissing);
+  }
+
+  private initializeFilePaths(qenvFileBasePathArg: string, envFileBasePathArg: string) {
     this.qenvFilePathAbsolute = plugins.path.join(
       plugins.path.resolve(qenvFileBasePathArg),
       'qenv.yml'
     );
-    this.envFilePathAbsolute = plugins.path.join(
+    if (envFileBasePathArg) {
-      plugins.path.resolve(envFileBasePathArg),
+      this.envFilePathAbsolute = plugins.path.join(
-      'env.json'
+        plugins.path.resolve(envFileBasePathArg),
+        'env.json'
+      );
+    }
+  }
+
+  private loadRequiredEnvVars() {
+    if (plugins.smartfile.fs.fileExistsSync(this.qenvFilePathAbsolute)) {
+      const qenvFile = plugins.smartfile.fs.toObjectSync(this.qenvFilePathAbsolute);
+      if (qenvFile?.required && Array.isArray(qenvFile.required)) {
+        this.requiredEnvVars.push(...qenvFile.required);
+      } else {
+        this.logger.log('warn', 'qenv.yml does not contain a "required" Array!');
+      }
+    }
+  }
+
+  private loadAvailableEnvVars() {
+    for (const envVar of this.requiredEnvVars) {
+      const value = this.getEnvVarOnDemand(envVar);
+      if (value) {
+        this.availableEnvVars.push(envVar);
+        this.keyValueObject[envVar] = value;
+      }
+    }
+  }
+
+  private checkForMissingEnvVars(failOnMissing: boolean) {
+    this.missingEnvVars = this.requiredEnvVars.filter(
+      (envVar) => !this.availableEnvVars.includes(envVar)
     );
 
-    this.getRequiredEnvVars();
-    this.getAvailableEnvVars();
-
-    this.missingEnvVars = this.getMissingEnvVars();
-
-    // handle missing variables
     if (this.missingEnvVars.length > 0) {
-      console.info('Required Env Vars are:');
+      console.info('Required Env Vars are:', this.requiredEnvVars);
-      console.log(this.requiredEnvVars);
+      console.error('Missing Env Vars:', this.missingEnvVars);
-      console.error('However some Env variables could not be resolved:');
-      console.log(this.missingEnvVars);
       if (failOnMissing) {
-        this.logger.log('error', 'Exiting!');
+        this.logger.log('error', 'Exiting due to missing env vars!');
         process.exit(1);
       } else {
         this.logger.log('warn', 'qenv is not set to fail on missing environment variables');
@@ -46,150 +78,121 @@ export class Qenv {
     }
   }
 
-  /**
+  public async getEnvVarOnDemand(
-   * only gets an environment variable if it is required within a read qenv.yml file
+    envVarNameOrNames: TEnvVarRef | TEnvVarRef[]
-   * @param envVarName
+  ): Promise<string | undefined> {
-   */
+    if (Array.isArray(envVarNameOrNames)) {
-  public getEnvVarRequired(envVarName): string {
+      for (const envVarName of envVarNameOrNames) {
-    return this.keyValueObject[envVarName];
+        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 {
-   * tries to get any env var even if it is not required
+    console.warn('requesting env var sync leaves out potentially important async env sources.');
-   * @param wantedEnvVar
-   */
-  public getEnvVarOnDemand(wantedEnvVar: string): string {
-    let envVarFromEnvironmentVariable: string;
-    let envVarFromEnvJsonFile: string;
-    let envVarFromDockerSecret: string;
-    let dockerSecretJson: string;
 
-    // env var check
+    if (Array.isArray(envVarNameOrNames)) {
-    if (process.env[wantedEnvVar]) {
+      for (const envVarName of envVarNameOrNames) {
-      this.availableEnvVars.push(wantedEnvVar);
+        const value = this.tryGetEnvVarSync(envVarName);
-      envVarFromEnvironmentVariable = process.env[wantedEnvVar];
+        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(envVarRefArg: TEnvVarRef): Promise<string | undefined> {
+    if (typeof envVarRefArg === 'function') {
+      return await envVarRefArg();
     }
 
-    // env file check
+    return (
-    // lets determine the actual env yml
+      this.getFromEnvironmentVariable(envVarRefArg) ||
-    let envJsonFileAsObject;
+      this.getFromEnvJsonFile(envVarRefArg) ||
+      this.getFromDockerSecret(envVarRefArg) ||
+      this.getFromDockerSecretJson(envVarRefArg)
+    );
+  }
+
+  private tryGetEnvVarSync(envVarName: string): string | undefined {
+    return (
+      this.getFromEnvironmentVariable(envVarName) ||
+      this.getFromEnvJsonFile(envVarName) ||
+      this.getFromDockerSecret(envVarName) ||
+      this.getFromDockerSecretJson(envVarName)
+    );
+  }
+
+  private getFromEnvironmentVariable(envVarName: string): string | undefined {
+    return process.env[envVarName];
+  }
+
+  private getFromEnvJsonFile(envVarName: string): string | undefined {
+    if (!plugins.smartfile.fs.fileExistsSync(this.envFilePathAbsolute)) {
+      return undefined;
+    }
     try {
-      envJsonFileAsObject = plugins.smartfile.fs.toObjectSync(this.envFilePathAbsolute);
+      const envJson = plugins.smartfile.fs.toObjectSync(this.envFilePathAbsolute);
-    } catch (err) {
+      const value = envJson[envVarName];
-      envJsonFileAsObject = {};
+      if (typeof value === 'object') {
-    }
+        return 'base64Object:' + this.encodeBase64(value);
-    if (envJsonFileAsObject.hasOwnProperty(wantedEnvVar)) {
+      }
-      envVarFromEnvJsonFile = envJsonFileAsObject[wantedEnvVar];
+      return value;
+    } catch (error) {
+      return undefined;
     }
+  }
 
-    // docker secret check
+  private getFromDockerSecret(envVarName: string): string | undefined {
-    if (
+    const secretPath = `/run/secrets/${envVarName}`;
-      plugins.smartfile.fs.isDirectory('/run') &&
+    if (plugins.smartfile.fs.fileExistsSync(secretPath)) {
-      plugins.smartfile.fs.isDirectory('/run/secrets') &&
+      return plugins.smartfile.fs.toStringSync(secretPath);
-      plugins.smartfile.fs.fileExistsSync(`/run/secrets/${wantedEnvVar}`)
-    ) {
-      envVarFromDockerSecret = plugins.smartfile.fs.toStringSync(`/run/secrets/${wantedEnvVar}`);
     }
+    return undefined;
+  }
 
-    // docker secret.json
+  private getFromDockerSecretJson(envVarName: string): string | undefined {
-    if (
+    if (plugins.smartfile.fs.isDirectory('/run/secrets')) {
-      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') && !envVarFromDockerSecret) {
+        if (secret.includes('secret.json')) {
           const secretObject = plugins.smartfile.fs.toObjectSync(`/run/secrets/${secret}`);
-          envVarFromDockerSecret = secretObject[wantedEnvVar];
+          const value = secretObject[envVarName];
+          if (typeof value === 'object') {
+            return 'base64Object:' + this.encodeBase64(value);
+          }
+          return value;
         }
       }
     }
-
+    return undefined;
-    // warn if there is more than one candidate
-    const availableCcandidates: any[] = [];
-    [
-      envVarFromEnvironmentVariable,
-      envVarFromEnvJsonFile,
-      envVarFromDockerSecret,
-      dockerSecretJson,
-    ].forEach((candidate) => {
-      if (candidate) {
-        availableCcandidates.push(candidate);
-      }
-    });
-    if (availableCcandidates.length > 1) {
-      this.logger.log(
-        'warn',
-        `found multiple candidates for ${wantedEnvVar} Choosing in the order of envVar, envFileVar, dockerSecret, dockerSecretJson`
-      );
-      console.log(availableCcandidates);
-    }
-
-    switch (true) {
-      case !!envVarFromEnvironmentVariable:
-        this.logger.log('ok', `found ${wantedEnvVar} as environment variable`);
-        return envVarFromEnvironmentVariable;
-      case !!envVarFromEnvJsonFile:
-        this.logger.log('ok', `found ${wantedEnvVar} as env.json variable`);
-        return envVarFromEnvJsonFile;
-      case !!envVarFromDockerSecret:
-        this.logger.log('ok', `found ${wantedEnvVar} as docker secret`);
-        return envVarFromDockerSecret;
-      case !!dockerSecretJson:
-        this.logger.log('ok', `found ${wantedEnvVar} as docker secret.json`);
-        return dockerSecretJson;
-      default:
-        this.logger.log(
-          'warn',
-          `could not find the wanted environment variable ${wantedEnvVar} anywhere`
-        );
-        return;
-    }
   }
 
-  /**
+  private encodeBase64(data: any): string {
-   * gets the required env values
+    const jsonString = JSON.stringify(data);
-   */
+    return Buffer.from(jsonString).toString('base64');
-  private getRequiredEnvVars = () => {
+  }
-    let qenvFile: any = {};
-    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',
-        `qenv (promised environment): ./qenv.yml File does not contain a 'required' Array! This might be ok though.`
-      );
-    } else {
-      for (const keyArg of Object.keys(qenvFile.required)) {
-        this.requiredEnvVars.push(qenvFile.required[keyArg]);
-      }
-    }
-  };
 
-  /**
+  private decodeBase64(encodedString: string): any {
-   * gets the available env vars
+    const decodedString = Buffer.from(encodedString, 'base64').toString('utf-8');
-   */
+    return JSON.parse(decodedString);
-  private getAvailableEnvVars = () => {
+  }
-    for (const requiredEnvVar of this.requiredEnvVars) {
-      const chosenVar = this.getEnvVarOnDemand(requiredEnvVar);
-      if (chosenVar) {
-        this.availableEnvVars.push(requiredEnvVar);
-        this.keyValueObject[requiredEnvVar] = chosenVar;
-      }
-    }
-  };
-
-  /**
-   * gets missing env vars
-   */
-  private getMissingEnvVars = (): string[] => {
-    const missingEnvVars: string[] = [];
-    for (const envVar of this.requiredEnvVars) {
-      if (!this.availableEnvVars.includes(envVar)) {
-        missingEnvVars.push(envVar);
-      }
-    }
-    return missingEnvVars;
-  };
 }

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 };

tsconfig.json

@@ -3,9 +3,12 @@
     "experimentalDecorators": true,
     "useDefineForClassFields": false,
     "target": "ES2022",
-    "module": "ES2022",
+    "module": "NodeNext",
-    "moduleResolution": "nodenext",
+    "moduleResolution": "NodeNext",
     "esModuleInterop": true,
-    "verbatimModuleSyntax": true,
+    "verbatimModuleSyntax": true
-  }
+  },
+  "exclude": [
+    "dist_*/**/*.d.ts"
+  ]
 }