@push.rocks/qenv 7.0.0 → 8.0.0

package/dist_ts/00_commitinfo_data.js

@@ -3,7 +3,7 @@
  */
 export const commitinfo = {
     name: '@push.rocks/qenv',
-    version: '7.0.0',
+    version: '8.0.0',
     description: 'A module for easily handling environment variables in Node.js projects with support for .yml and .json configuration.'
 };
 //# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiMDBfY29tbWl0aW5mb19kYXRhLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vdHMvMDBfY29tbWl0aW5mb19kYXRhLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBQ0gsTUFBTSxDQUFDLE1BQU0sVUFBVSxHQUFHO0lBQ3hCLElBQUksRUFBRSxrQkFBa0I7SUFDeEIsT0FBTyxFQUFFLE9BQU87SUFDaEIsV0FBVyxFQUFFLHVIQUF1SDtDQUNySSxDQUFBIn0=

package/dist_ts/index.d.ts

@@ -1 +1,2 @@
 export * from './qenv.classes.qenv.js';
+export * from './qenv.classes.missingrequiredenvvarserror.js';

package/dist_ts/index.js

@@ -1,2 +1,3 @@
 export * from './qenv.classes.qenv.js';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi90cy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLHdCQUF3QixDQUFDIn0=
+export * from './qenv.classes.missingrequiredenvvarserror.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi90cy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLHdCQUF3QixDQUFDO0FBQ3ZDLGNBQWMsK0NBQStDLENBQUMifQ==

package/dist_ts/qenv.classes.missingrequiredenvvarserror.d.ts

@@ -0,0 +1,18 @@
+export interface IQenvMissingRequiredEnvVarsErrorOptions {
+    missingEnvVars: string[];
+    requiredEnvVars: string[];
+    qenvFilePathAbsolute: string;
+}
+/**
+ * Thrown when a variable listed under `required:` in qenv.yml is not provided by any source.
+ * The names are carried as data so a caller can report or branch on them without parsing the
+ * message, and `code` identifies the refusal even when two copies of qenv end up in one tree,
+ * which makes `instanceof` unreliable.
+ */
+export declare class QenvMissingRequiredEnvVarsError extends Error {
+    readonly code = "QENV_MISSING_REQUIRED_ENV_VARS";
+    readonly missingEnvVars: string[];
+    readonly requiredEnvVars: string[];
+    readonly qenvFilePathAbsolute: string;
+    constructor(optionsArg: IQenvMissingRequiredEnvVarsErrorOptions);
+}

package/dist_ts/qenv.classes.missingrequiredenvvarserror.js

@@ -0,0 +1,19 @@
+/**
+ * Thrown when a variable listed under `required:` in qenv.yml is not provided by any source.
+ * The names are carried as data so a caller can report or branch on them without parsing the
+ * message, and `code` identifies the refusal even when two copies of qenv end up in one tree,
+ * which makes `instanceof` unreliable.
+ */
+export class QenvMissingRequiredEnvVarsError extends Error {
+    constructor(optionsArg) {
+        super(`qenv is missing required environment variables: ${optionsArg.missingEnvVars.join(', ')}. ` +
+            `They are listed under "required:" in ${optionsArg.qenvFilePathAbsolute} and were found ` +
+            `neither in the process environment, nor in the env file, nor in the Docker secrets.`);
+        this.code = 'QENV_MISSING_REQUIRED_ENV_VARS';
+        this.name = 'QenvMissingRequiredEnvVarsError';
+        this.missingEnvVars = [...optionsArg.missingEnvVars];
+        this.requiredEnvVars = [...optionsArg.requiredEnvVars];
+        this.qenvFilePathAbsolute = optionsArg.qenvFilePathAbsolute;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicWVudi5jbGFzc2VzLm1pc3NpbmdyZXF1aXJlZGVudnZhcnNlcnJvci5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3RzL3FlbnYuY2xhc3Nlcy5taXNzaW5ncmVxdWlyZWRlbnZ2YXJzZXJyb3IudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBTUE7Ozs7O0dBS0c7QUFDSCxNQUFNLE9BQU8sK0JBQWdDLFNBQVEsS0FBSztJQU14RCxZQUFZLFVBQW1EO1FBQzdELEtBQUssQ0FDSCxtREFBbUQsVUFBVSxDQUFDLGNBQWMsQ0FBQyxJQUFJLENBQUMsSUFBSSxDQUFDLElBQUk7WUFDekYsd0NBQXdDLFVBQVUsQ0FBQyxvQkFBb0Isa0JBQWtCO1lBQ3pGLHFGQUFxRixDQUN4RixDQUFDO1FBVlksU0FBSSxHQUFHLGdDQUFnQyxDQUFDO1FBV3RELElBQUksQ0FBQyxJQUFJLEdBQUcsaUNBQWlDLENBQUM7UUFDOUMsSUFBSSxDQUFDLGNBQWMsR0FBRyxDQUFDLEdBQUcsVUFBVSxDQUFDLGNBQWMsQ0FBQyxDQUFDO1FBQ3JELElBQUksQ0FBQyxlQUFlLEdBQUcsQ0FBQyxHQUFHLFVBQVUsQ0FBQyxlQUFlLENBQUMsQ0FBQztRQUN2RCxJQUFJLENBQUMsb0JBQW9CLEdBQUcsVUFBVSxDQUFDLG9CQUFvQixDQUFDO0lBQzlELENBQUM7Q0FDRiJ9

package/dist_ts/qenv.classes.qenv.d.ts

@@ -1,32 +1,71 @@
 import * as plugins from './qenv.plugins.js';
+/**
+ * a reference to an environment variable: its name, or an async function that produces the value.
+ * The function form is only honoured by the async getters; the synchronous getter accepts names.
+ */
 export type TEnvVarRef = string | (() => Promise<string>);
-type TKeyValueObject = Record<string, any>;
+/** the resolved value of every available required env var, always a string */
+export type TEnvVarValueMap = Record<string, string>;
 export declare class Qenv {
+    /** the names listed under `required:` in qenv.yml */
     requiredEnvVars: string[];
+    /** the required names that a source provided */
     availableEnvVars: string[];
+    /** the required names that no source provided */
     missingEnvVars: string[];
-    keyValueObject: TKeyValueObject;
+    /** the resolved value of every available required name */
+    keyValueObject: TEnvVarValueMap;
     logger: plugins.smartlog.ConsoleLog;
     qenvFilePathAbsolute: string;
     envFilePathAbsolute?: string;
+    /**
+     * Resolves every name listed under `required:` in qenv.yml while constructing.
+     * @param qenvFileBasePathArg directory that holds qenv.yml
+     * @param envFileBasePathArg directory that holds env.json, env.yml or env.yaml
+     * @param failOnMissing throws a QenvMissingRequiredEnvVarsError when a variable listed under
+     * `required:` in qenv.yml is not provided by any source. Pass false to only record the names in
+     * `missingEnvVars` and continue.
+     * @throws QenvMissingRequiredEnvVarsError
+     */
     constructor(qenvFileBasePathArg?: string, envFileBasePathArg?: string, failOnMissing?: boolean);
     private initializeFilePaths;
     private loadRequiredEnvVars;
     private loadAvailableEnvVars;
     private checkForMissingEnvVars;
+    /**
+     * Resolves an env var from the process environment, the env file and the Docker secrets, in that
+     * order. An array is tried left to right and the first defined value wins.
+     * @param envVarNameOrNames a name, an async resolver function, or a list of either
+     */
     getEnvVarOnDemand(envVarNameOrNames: TEnvVarRef | TEnvVarRef[]): Promise<string | undefined>;
     /**
-     * Like getEnvVarOnDemand, but throws an error if the env var is not set.
-     * @param envVarNameOrNames
-     * @returns
+     * Like getEnvVarOnDemand, but throws when no source provides a value.
+     * @param envVarNameOrNames a name, an async resolver function, or a list of either
      */
     getEnvVarOnDemandStrict(envVarNameOrNames: TEnvVarRef | TEnvVarRef[]): Promise<string>;
+    /**
+     * The synchronous counterpart of getEnvVarOnDemand. It resolves names only: an async resolver
+     * function cannot be awaited here, so the function form of TEnvVarRef is not accepted.
+     * @param envVarNameOrNames a name or a list of names
+     */
     getEnvVarOnDemandSync(envVarNameOrNames: string | string[]): string | undefined;
-    getEnvVarOnDemandAsObject(envVarNameOrNames: string | string[]): Promise<any>;
+    /**
+     * Resolves an env var whose value was stored as a base64 encoded object and decodes it. A plain
+     * value is returned as the string it is, so the caller narrows what it gets.
+     * @param envVarNameOrNames a name or a list of names
+     */
+    getEnvVarOnDemandAsObject(envVarNameOrNames: string | string[]): Promise<unknown>;
     private tryGetEnvVar;
     private tryGetEnvVarSync;
+    /** renders env var references for an error message, naming a resolver function where it has one */
+    private describeEnvVarRefs;
     private getFromEnvironmentVariable;
     private getFromEnvYamlOrJsonFile;
+    /**
+     * the directory Docker mounts secrets into. It is a method so a test can point both secret
+     * readers at a directory it is allowed to create; a process can never write /run/secrets itself.
+     */
+    protected getDockerSecretsDirectoryPath(): string;
     private getFromDockerSecret;
     private getFromDockerSecretJson;
     private encodeBase64;
@@ -35,4 +74,3 @@ export declare class Qenv {
     private directoryExists;
     private readObjectFromFile;
 }
-export {};

package/dist_ts/qenv.classes.qenv.js

@@ -1,9 +1,23 @@
 import * as plugins from './qenv.plugins.js';
+import { QenvMissingRequiredEnvVarsError } from './qenv.classes.missingrequiredenvvarserror.js';
 export class Qenv {
+    /**
+     * Resolves every name listed under `required:` in qenv.yml while constructing.
+     * @param qenvFileBasePathArg directory that holds qenv.yml
+     * @param envFileBasePathArg directory that holds env.json, env.yml or env.yaml
+     * @param failOnMissing throws a QenvMissingRequiredEnvVarsError when a variable listed under
+     * `required:` in qenv.yml is not provided by any source. Pass false to only record the names in
+     * `missingEnvVars` and continue.
+     * @throws QenvMissingRequiredEnvVarsError
+     */
     constructor(qenvFileBasePathArg = process.cwd(), envFileBasePathArg, failOnMissing = true) {
+        /** the names listed under `required:` in qenv.yml */
         this.requiredEnvVars = [];
+        /** the required names that a source provided */
         this.availableEnvVars = [];
+        /** the required names that no source provided */
         this.missingEnvVars = [];
+        /** the resolved value of every available required name */
         this.keyValueObject = {};
         this.logger = new plugins.smartlog.ConsoleLog();
         this.qenvFilePathAbsolute = '';
@@ -38,20 +52,25 @@ export class Qenv {
         }
     }
     loadRequiredEnvVars() {
-        if (this.fileExists(this.qenvFilePathAbsolute)) {
-            const qenvFile = this.readObjectFromFile(this.qenvFilePathAbsolute);
-            const requiredEnvVars = qenvFile.required;
-            if (Array.isArray(requiredEnvVars)) {
-                this.requiredEnvVars.push(...requiredEnvVars.filter((envVar) => typeof envVar === 'string'));
-            }
-            else {
-                this.logger.log('warn', 'qenv.yml does not contain a "required" Array!');
-            }
+        if (!this.fileExists(this.qenvFilePathAbsolute)) {
+            return;
         }
+        const qenvFile = this.readObjectFromFile(this.qenvFilePathAbsolute);
+        const declaredRequirements = qenvFile['required'];
+        if (!Array.isArray(declaredRequirements)) {
+            this.logger.log('warn', 'qenv.yml does not contain a "required" Array!');
+            return;
+        }
+        const declaredEntries = declaredRequirements;
+        this.requiredEnvVars.push(...declaredEntries.filter((entry) => typeof entry === 'string'));
     }
     loadAvailableEnvVars() {
+        // resolved synchronously: a required env var is always a name, and every source a name can come
+        // from - process environment, env file, Docker secrets - is a synchronous read. Resolving it
+        // here as a promise would store a pending promise instead of a value and make the check below
+        // pass for every name.
         for (const envVar of this.requiredEnvVars) {
-            const value = this.getEnvVarOnDemand(envVar);
+            const value = this.tryGetEnvVarSync(envVar);
             if (value !== undefined) {
                 this.availableEnvVars.push(envVar);
                 this.keyValueObject[envVar] = value;
@@ -60,18 +79,24 @@ export class Qenv {
     }
     checkForMissingEnvVars(failOnMissing) {
         this.missingEnvVars = this.requiredEnvVars.filter((envVar) => !this.availableEnvVars.includes(envVar));
-        if (this.missingEnvVars.length > 0) {
-            console.info('Required Env Vars are:', this.requiredEnvVars);
-            console.error('Missing Env Vars:', this.missingEnvVars);
-            if (failOnMissing) {
-                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');
-            }
+        if (this.missingEnvVars.length === 0) {
+            return;
         }
+        if (failOnMissing) {
+            // a library must not end the process: the caller decides what an incomplete environment means
+            throw new QenvMissingRequiredEnvVarsError({
+                missingEnvVars: this.missingEnvVars,
+                requiredEnvVars: this.requiredEnvVars,
+                qenvFilePathAbsolute: this.qenvFilePathAbsolute,
+            });
+        }
+        this.logger.log('warn', `qenv is not set to fail on missing environment variables. Missing: ${this.missingEnvVars.join(', ')}`);
     }
+    /**
+     * Resolves an env var from the process environment, the env file and the Docker secrets, in that
+     * order. An array is tried left to right and the first defined value wins.
+     * @param envVarNameOrNames a name, an async resolver function, or a list of either
+     */
     async getEnvVarOnDemand(envVarNameOrNames) {
         if (Array.isArray(envVarNameOrNames)) {
             for (const envVarName of envVarNameOrNames) {
@@ -87,19 +112,22 @@ export class Qenv {
         }
     }
     /**
-     * Like getEnvVarOnDemand, but throws an error if the env var is not set.
-     * @param envVarNameOrNames
-     * @returns
+     * Like getEnvVarOnDemand, but throws when no source provides a value.
+     * @param envVarNameOrNames a name, an async resolver function, or a list of either
      */
     async getEnvVarOnDemandStrict(envVarNameOrNames) {
         const value = await this.getEnvVarOnDemand(envVarNameOrNames);
         if (value === undefined) {
-            throw new Error(`Env var ${envVarNameOrNames} is not set!`);
+            throw new Error(`Env var ${this.describeEnvVarRefs(envVarNameOrNames)} is not set!`);
         }
         return value;
     }
+    /**
+     * The synchronous counterpart of getEnvVarOnDemand. It resolves names only: an async resolver
+     * function cannot be awaited here, so the function form of TEnvVarRef is not accepted.
+     * @param envVarNameOrNames a name or a list of names
+     */
     getEnvVarOnDemandSync(envVarNameOrNames) {
-        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);
@@ -113,6 +141,11 @@ export class Qenv {
             return this.tryGetEnvVarSync(envVarNameOrNames);
         }
     }
+    /**
+     * Resolves an env var whose value was stored as a base64 encoded object and decodes it. A plain
+     * value is returned as the string it is, so the caller narrows what it gets.
+     * @param envVarNameOrNames a name or a list of names
+     */
     async getEnvVarOnDemandAsObject(envVarNameOrNames) {
         const rawValue = await this.getEnvVarOnDemand(envVarNameOrNames);
         if (rawValue && rawValue.startsWith('base64Object:')) {
@@ -125,33 +158,36 @@ export class Qenv {
         if (typeof envVarRefArg === 'function') {
             return await envVarRefArg();
         }
-        const sources = [
-            this.getFromEnvironmentVariable(envVarRefArg),
-            this.getFromEnvYamlOrJsonFile(envVarRefArg),
-            this.getFromDockerSecret(envVarRefArg),
-            this.getFromDockerSecretJson(envVarRefArg)
-        ];
-        for (const value of sources) {
-            if (value !== undefined) {
-                return value;
-            }
-        }
-        return undefined;
+        // a name resolves from synchronous sources only, so both getters share one resolution order
+        return this.tryGetEnvVarSync(envVarRefArg);
     }
     tryGetEnvVarSync(envVarName) {
+        // read lazily: a source is only touched once every earlier one came back undefined, so a name
+        // the process environment answers never opens a secret file, and a malformed secret.json only
+        // ever affects the names that actually reach it
         const sources = [
-            this.getFromEnvironmentVariable(envVarName),
-            this.getFromEnvYamlOrJsonFile(envVarName),
-            this.getFromDockerSecret(envVarName),
-            this.getFromDockerSecretJson(envVarName)
+            () => this.getFromEnvironmentVariable(envVarName),
+            () => this.getFromEnvYamlOrJsonFile(envVarName),
+            () => this.getFromDockerSecret(envVarName),
+            () => this.getFromDockerSecretJson(envVarName),
         ];
-        for (const value of sources) {
+        for (const readSource of sources) {
+            const value = readSource();
             if (value !== undefined) {
                 return value;
             }
         }
         return undefined;
     }
+    /** renders env var references for an error message, naming a resolver function where it has one */
+    describeEnvVarRefs(envVarNameOrNames) {
+        const envVarRefs = Array.isArray(envVarNameOrNames) ? envVarNameOrNames : [envVarNameOrNames];
+        return envVarRefs
+            .map((envVarRef) => typeof envVarRef === 'function'
+            ? `${envVarRef.name || 'anonymous'}()`
+            : envVarRef)
+            .join(', ');
+    }
     getFromEnvironmentVariable(envVarName) {
         return process.env[envVarName];
     }
@@ -174,19 +210,27 @@ export class Qenv {
             return undefined;
         }
     }
+    /**
+     * the directory Docker mounts secrets into. It is a method so a test can point both secret
+     * readers at a directory it is allowed to create; a process can never write /run/secrets itself.
+     */
+    getDockerSecretsDirectoryPath() {
+        return '/run/secrets';
+    }
     getFromDockerSecret(envVarName) {
-        const secretPath = `/run/secrets/${envVarName}`;
+        const secretPath = plugins.path.join(this.getDockerSecretsDirectoryPath(), envVarName);
         if (this.fileExists(secretPath)) {
             return plugins.fs.readFileSync(secretPath, 'utf8');
         }
         return undefined;
     }
     getFromDockerSecretJson(envVarName) {
-        if (this.directoryExists('/run/secrets')) {
-            const availableSecrets = plugins.fs.readdirSync('/run/secrets');
+        const secretsDirectoryPath = this.getDockerSecretsDirectoryPath();
+        if (this.directoryExists(secretsDirectoryPath)) {
+            const availableSecrets = plugins.fs.readdirSync(secretsDirectoryPath);
             for (const secret of availableSecrets) {
                 if (secret.includes('secret.json')) {
-                    const secretObject = this.readObjectFromFile(`/run/secrets/${secret}`);
+                    const secretObject = this.readObjectFromFile(plugins.path.join(secretsDirectoryPath, secret));
                     const value = secretObject[envVarName];
                     if (value === undefined) {
                         continue;
@@ -227,7 +271,9 @@ export class Qenv {
         const parsedObject = filePath.endsWith('.json')
             ? JSON.parse(fileString)
             : plugins.yaml.parse(fileString);
-        return typeof parsedObject === 'object' && parsedObject !== null ? parsedObject : {};
+        return typeof parsedObject === 'object' && parsedObject !== null
+            ? parsedObject
+            : {};
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"qenv.classes.qenv.js","sourceRoot":"","sources":["../ts/qenv.classes.qenv.ts"],"names":[],"mappings":"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"}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"qenv.classes.qenv.js","sourceRoot":"","sources":["../ts/qenv.classes.qenv.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@push.rocks/qenv",
-  "version": "7.0.0",
+  "version": "8.0.0",
   "private": false,
   "description": "A module for easily handling environment variables in Node.js projects with support for .yml and .json configuration.",
   "main": "dist_ts/index.js",
@@ -22,14 +22,14 @@
   "author": "Task Venture Capital GmbH <hello@task.vc>",
   "license": "MIT",
   "bugs": {
-    "url": "https://gitlab.com/pushrocks/qenv/issues"
+    "url": "https://code.foss.global/push.rocks/qenv/issues"
   },
   "homepage": "https://code.foss.global/push.rocks/qenv",
   "devDependencies": {
-    "@git.zone/tsbuild": "^4.4.3",
+    "@git.zone/tsbuild": "^4.5.0",
     "@git.zone/tsrun": "^2.0.6",
-    "@git.zone/tstest": "^6.1.0",
-    "@types/node": "^26.5.0"
+    "@git.zone/tstest": "^6.1.1",
+    "@types/node": "^26.5.1"
   },
   "dependencies": {
     "@push.rocks/smartlog": "^3.2.2",

package/readme.md

@@ -10,7 +10,8 @@
 ✅ **Flexible Formats** - Supports `.yml`, `.yaml`, and `.json` configuration files  
 ✅ **Docker Ready** - Built-in support for Docker secrets and secret.json files  
 ✅ **Async & Sync** - Both synchronous and asynchronous variable retrieval  
-✅ **Strict Mode** - Optional strict mode that throws errors for missing variables  
+✅ **Enforced Requirements** - `required:` in `qenv.yml` is checked while constructing, with a typed error  
+✅ **Strict Mode** - Optional strict getter that throws for a missing variable  
 ✅ **Base64 Objects** - Handle complex configuration objects with automatic encoding/decoding  
 ✅ **Dynamic Resolution** - Support for async functions as environment variable sources  
 
@@ -32,7 +33,8 @@ yarn add @push.rocks/qenv
 ```typescript
 import { Qenv } from '@push.rocks/qenv';
 
-// Create a new Qenv instance
+// Create a new Qenv instance. Every name listed under `required:` in qenv.yml is resolved right
+// here, and a missing one throws a QenvMissingRequiredEnvVarsError.
 const qenv = new Qenv('./', './', true);
 
 // Access environment variables
@@ -61,6 +63,10 @@ required:
   - LOG_LEVEL
 ```
 
+Every listed name is resolved while the `Qenv` instance is constructed. What is found lands in
+`availableEnvVars` and, as a string, in `keyValueObject`; what is missing lands in `missingEnvVars`
+and, unless you pass `failOnMissing: false`, makes the constructor throw.
+
 #### 2. Provide Values (`env.yml` or `env.json`)
 
 For local development, create an `env.yml` or `env.json` file:
@@ -97,6 +103,10 @@ Qenv loads variables in this order (first found wins):
 3. **Docker secrets** - From `/run/secrets/`
 4. **Docker secret JSON** - From `/run/secrets/secret.json`
 
+All four sources are synchronous, so `getEnvVarOnDemand` and `getEnvVarOnDemandSync` resolve a name
+identically. A `required:` entry is always a name; an async resolver function is a per-call source
+and never takes part in the requirement check.
+
 ### Handling Complex Objects
 
 Store and retrieve complex configuration objects:
@@ -134,6 +144,9 @@ const fetchFromVault = async () => {
 const secret = await qenv.getEnvVarOnDemand(fetchFromVault);
 ```
 
+The function form of `TEnvVarRef` is honoured by `getEnvVarOnDemand` and `getEnvVarOnDemandStrict`
+only. `getEnvVarOnDemandSync` cannot await, so it accepts names and takes no resolver function.
+
 ### Working with Docker
 
 Qenv seamlessly integrates with Docker secrets:
@@ -168,9 +181,18 @@ const dbPassword = await qenv.getEnvVarOnDemand('db_password');
 Control how your application handles missing environment variables:
 
 ```typescript
-// Fail fast (default behavior)
-const qenvStrict = new Qenv('./', './', true);
-// Application exits if required variables are missing
+import { Qenv, QenvMissingRequiredEnvVarsError } from '@push.rocks/qenv';
+
+// Fail fast (default behaviour): the constructor throws
+try {
+  const qenvStrict = new Qenv('./', './', true);
+} catch (error) {
+  if (error instanceof QenvMissingRequiredEnvVarsError) {
+    console.error('Missing variables:', error.missingEnvVars);
+    console.error('Declared in:', error.qenvFilePathAbsolute);
+  }
+  throw error;
+}
 
 // Graceful handling
 const qenvRelaxed = new Qenv('./', './', false);
@@ -183,6 +205,16 @@ if (qenvRelaxed.missingEnvVars.length > 0) {
 }
 ```
 
+qenv never ends the process: the caller decides what an incomplete environment means. Where two
+copies of qenv can end up in one dependency tree, `instanceof` is unreliable - match on the code
+instead:
+
+```typescript
+if (error instanceof Error && 'code' in error && error.code === 'QENV_MISSING_REQUIRED_ENV_VARS') {
+  // handle the incomplete environment
+}
+```
+
 ### Strict Mode for Critical Variables
 
 Use the new strict getter when you absolutely need a variable:
@@ -191,15 +223,19 @@ Use the new strict getter when you absolutely need a variable:
 try {
   // This will throw if TOKEN is not set
   const token = await qenv.getEnvVarOnDemandStrict('TOKEN');
-  
+
   // You can also check multiple fallback names
   const db = await qenv.getEnvVarOnDemandStrict(['DATABASE_URL', 'DB_CONNECTION']);
 } catch (error) {
+  // the message names every reference that could not be resolved
   console.error('Critical configuration missing:', error.message);
-  process.exit(1);
+  throw error;
 }
 ```
 
+A name that `qenv.yml` already lists under `required:` is resolved at construction time, so the
+strict getter is for variables you look up on demand.
+
 ## 🏗️ CI/CD Integration
 
 ### GitHub Actions
@@ -276,12 +312,12 @@ qenv.logger.log('info', 'Custom log message');
 Here's how you might use qenv in a production Node.js application:
 
 ```typescript
-import { Qenv } from '@push.rocks/qenv';
+import { Qenv, QenvMissingRequiredEnvVarsError } from '@push.rocks/qenv';
 import { createServer } from './server';
 import { connectDatabase } from './database';
 
 async function bootstrap() {
-  // Initialize environment
+  // Initialize environment: throws when qenv.yml requires something no source provides
   const qenv = new Qenv();
   
   // Load critical configuration
@@ -304,7 +340,12 @@ async function bootstrap() {
 }
 
 bootstrap().catch(error => {
-  console.error('Failed to start application:', error);
+  if (error instanceof QenvMissingRequiredEnvVarsError) {
+    console.error('Incomplete environment, missing:', error.missingEnvVars.join(', '));
+  } else {
+    console.error('Failed to start application:', error);
+  }
+  // exiting is the application's decision - qenv itself never calls process.exit
   process.exit(1);
 });
 ```
@@ -318,18 +359,21 @@ bootstrap().catch(error => {
 new Qenv(
   qenvFileBasePathArg?: string,  // Path to qenv.yml (default: process.cwd())
   envFileBasePathArg?: string,   // Path to env.yml/json (default: same as qenv)
-  failOnMissing?: boolean        // Exit on missing vars (default: true)
+  failOnMissing?: boolean        // Throw on missing required vars (default: true)
 )
 ```
 
+Throws `QenvMissingRequiredEnvVarsError` when `failOnMissing` is true and a name listed under
+`required:` is not provided by any source.
+
 #### Methods
 
 | Method | Description | Returns |
 |--------|-------------|---------|
-| `getEnvVarOnDemand(name)` | Get environment variable value | `Promise<string \| undefined>` |
+| `getEnvVarOnDemand(name)` | Get environment variable value, resolver functions included | `Promise<string \| undefined>` |
 | `getEnvVarOnDemandStrict(name)` | Get variable or throw error | `Promise<string>` |
-| `getEnvVarOnDemandSync(name)` | Synchronously get variable | `string \| undefined` |
-| `getEnvVarOnDemandAsObject(name)` | Get variable as decoded object | `Promise<any>` |
+| `getEnvVarOnDemandSync(name)` | Synchronously get variable, names only | `string \| undefined` |
+| `getEnvVarOnDemandAsObject(name)` | Get variable as decoded object | `Promise<unknown>` |
 
 #### Properties
 
@@ -338,7 +382,24 @@ new Qenv(
 | `requiredEnvVars` | `string[]` | List of required variable names |
 | `availableEnvVars` | `string[]` | List of found variable names |
 | `missingEnvVars` | `string[]` | List of missing variable names |
-| `keyValueObject` | `object` | All loaded variables as key-value pairs |
+| `keyValueObject` | `Record<string, string>` | Every available required variable as a resolved string |
+| `qenvFilePathAbsolute` | `string` | Absolute path of the qenv.yml in use |
+| `envFilePathAbsolute` | `string \| undefined` | Absolute path of the env file in use |
+
+### Class: `QenvMissingRequiredEnvVarsError`
+
+Thrown by the constructor when `failOnMissing` is true and a required variable has no source.
+
+| Member | Type | Description |
+|--------|------|-------------|
+| `code` | `'QENV_MISSING_REQUIRED_ENV_VARS'` | Stable identifier, safe across duplicate installs |
+| `missingEnvVars` | `string[]` | The required names no source provided |
+| `requiredEnvVars` | `string[]` | Every name listed under `required:` |
+| `qenvFilePathAbsolute` | `string` | The qenv.yml that declared them |
+
+## Issue Reporting and Security
+
+For reporting bugs, issues, or security vulnerabilities, please visit [community.foss.global/](https://community.foss.global/). This is the central community hub for all issue reporting. Developers who sign and comply with our contribution agreement and go through identification can also get a [code.foss.global/](https://code.foss.global/) account to submit Pull Requests directly.
 
 ## License and Legal Information
 

package/ts/00_commitinfo_data.ts

@@ -3,6 +3,6 @@
  */
 export const commitinfo = {
   name: '@push.rocks/qenv',
-  version: '7.0.0',
+  version: '8.0.0',
   description: 'A module for easily handling environment variables in Node.js projects with support for .yml and .json configuration.'
 }

package/ts/index.ts

@@ -1 +1,2 @@
 export * from './qenv.classes.qenv.js';
+export * from './qenv.classes.missingrequiredenvvarserror.js';

package/ts/qenv.classes.missingrequiredenvvarserror.ts

@@ -0,0 +1,30 @@
+export interface IQenvMissingRequiredEnvVarsErrorOptions {
+  missingEnvVars: string[];
+  requiredEnvVars: string[];
+  qenvFilePathAbsolute: string;
+}
+
+/**
+ * Thrown when a variable listed under `required:` in qenv.yml is not provided by any source.
+ * The names are carried as data so a caller can report or branch on them without parsing the
+ * message, and `code` identifies the refusal even when two copies of qenv end up in one tree,
+ * which makes `instanceof` unreliable.
+ */
+export class QenvMissingRequiredEnvVarsError extends Error {
+  public readonly code = 'QENV_MISSING_REQUIRED_ENV_VARS';
+  public readonly missingEnvVars: string[];
+  public readonly requiredEnvVars: string[];
+  public readonly qenvFilePathAbsolute: string;
+
+  constructor(optionsArg: IQenvMissingRequiredEnvVarsErrorOptions) {
+    super(
+      `qenv is missing required environment variables: ${optionsArg.missingEnvVars.join(', ')}. ` +
+        `They are listed under "required:" in ${optionsArg.qenvFilePathAbsolute} and were found ` +
+        `neither in the process environment, nor in the env file, nor in the Docker secrets.`
+    );
+    this.name = 'QenvMissingRequiredEnvVarsError';
+    this.missingEnvVars = [...optionsArg.missingEnvVars];
+    this.requiredEnvVars = [...optionsArg.requiredEnvVars];
+    this.qenvFilePathAbsolute = optionsArg.qenvFilePathAbsolute;
+  }
+}

package/ts/qenv.classes.qenv.ts

@@ -1,18 +1,45 @@
 import * as plugins from './qenv.plugins.js';
+import { QenvMissingRequiredEnvVarsError } from './qenv.classes.missingrequiredenvvarserror.js';
 
+/**
+ * a reference to an environment variable: its name, or an async function that produces the value.
+ * The function form is only honoured by the async getters; the synchronous getter accepts names.
+ */
 export type TEnvVarRef = string | (() => Promise<string>);
-type TKeyValueObject = Record<string, any>;
+
+/** the resolved value of every available required env var, always a string */
+export type TEnvVarValueMap = Record<string, string>;
+
+/** a parsed qenv.yml, env file or secret.json, whose values are whatever the file declared */
+type TParsedFileObject = Record<string, unknown>;
 
 export class Qenv {
+  /** the names listed under `required:` in qenv.yml */
   public requiredEnvVars: string[] = [];
+
+  /** the required names that a source provided */
   public availableEnvVars: string[] = [];
+
+  /** the required names that no source provided */
   public missingEnvVars: string[] = [];
-  public keyValueObject: TKeyValueObject = {};
+
+  /** the resolved value of every available required name */
+  public keyValueObject: TEnvVarValueMap = {};
+
   public logger = new plugins.smartlog.ConsoleLog();
 
   public qenvFilePathAbsolute = '';
   public envFilePathAbsolute?: string;
 
+  /**
+   * Resolves every name listed under `required:` in qenv.yml while constructing.
+   * @param qenvFileBasePathArg directory that holds qenv.yml
+   * @param envFileBasePathArg directory that holds env.json, env.yml or env.yaml
+   * @param failOnMissing throws a QenvMissingRequiredEnvVarsError when a variable listed under
+   * `required:` in qenv.yml is not provided by any source. Pass false to only record the names in
+   * `missingEnvVars` and continue.
+   * @throws QenvMissingRequiredEnvVarsError
+   */
   constructor(
     qenvFileBasePathArg: string = process.cwd(),
     envFileBasePathArg?: string,
@@ -29,18 +56,18 @@ export class Qenv {
       plugins.path.resolve(qenvFileBasePathArg),
       'qenv.yml'
     );
-  
+
     if (envFileBasePathArg) {
       const envFileBasePath = plugins.path.resolve(envFileBasePathArg);
-  
+
       const envFileJsonPath = plugins.path.join(envFileBasePath, 'env.json');
       const envFileYmlPath = plugins.path.join(envFileBasePath, 'env.yml');
       const envFileYamlPath = plugins.path.join(envFileBasePath, 'env.yaml');
-  
+
       const envFileJsonExists = this.fileExists(envFileJsonPath);
       const envFileYmlExists = this.fileExists(envFileYmlPath);
       const envFileYamlExists = this.fileExists(envFileYamlPath);
-  
+
       if (envFileJsonExists && (envFileYmlExists || envFileYamlExists)) {
         this.logger.log('warn', 'Both env.json and env.yml files exist! Using env.json');
         this.envFilePathAbsolute = envFileJsonPath;
@@ -55,22 +82,28 @@ export class Qenv {
   }
 
   private loadRequiredEnvVars() {
-    if (this.fileExists(this.qenvFilePathAbsolute)) {
-      const qenvFile = this.readObjectFromFile(this.qenvFilePathAbsolute);
-      const requiredEnvVars = qenvFile.required;
-      if (Array.isArray(requiredEnvVars)) {
-        this.requiredEnvVars.push(
-          ...requiredEnvVars.filter((envVar): envVar is string => typeof envVar === 'string')
-        );
-      } else {
-        this.logger.log('warn', 'qenv.yml does not contain a "required" Array!');
-      }
+    if (!this.fileExists(this.qenvFilePathAbsolute)) {
+      return;
+    }
+    const qenvFile = this.readObjectFromFile(this.qenvFilePathAbsolute);
+    const declaredRequirements = qenvFile['required'];
+    if (!Array.isArray(declaredRequirements)) {
+      this.logger.log('warn', 'qenv.yml does not contain a "required" Array!');
+      return;
     }
+    const declaredEntries: unknown[] = declaredRequirements;
+    this.requiredEnvVars.push(
+      ...declaredEntries.filter((entry): entry is string => typeof entry === 'string')
+    );
   }
 
   private loadAvailableEnvVars() {
+    // resolved synchronously: a required env var is always a name, and every source a name can come
+    // from - process environment, env file, Docker secrets - is a synchronous read. Resolving it
+    // here as a promise would store a pending promise instead of a value and make the check below
+    // pass for every name.
     for (const envVar of this.requiredEnvVars) {
-      const value = this.getEnvVarOnDemand(envVar);
+      const value = this.tryGetEnvVarSync(envVar);
       if (value !== undefined) {
         this.availableEnvVars.push(envVar);
         this.keyValueObject[envVar] = value;
@@ -83,18 +116,30 @@ export class Qenv {
       (envVar) => !this.availableEnvVars.includes(envVar)
     );
 
-    if (this.missingEnvVars.length > 0) {
-      console.info('Required Env Vars are:', this.requiredEnvVars);
-      console.error('Missing Env Vars:', this.missingEnvVars);
-      if (failOnMissing) {
-        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');
-      }
+    if (this.missingEnvVars.length === 0) {
+      return;
     }
+
+    if (failOnMissing) {
+      // a library must not end the process: the caller decides what an incomplete environment means
+      throw new QenvMissingRequiredEnvVarsError({
+        missingEnvVars: this.missingEnvVars,
+        requiredEnvVars: this.requiredEnvVars,
+        qenvFilePathAbsolute: this.qenvFilePathAbsolute,
+      });
+    }
+
+    this.logger.log(
+      'warn',
+      `qenv is not set to fail on missing environment variables. Missing: ${this.missingEnvVars.join(', ')}`
+    );
   }
 
+  /**
+   * Resolves an env var from the process environment, the env file and the Docker secrets, in that
+   * order. An array is tried left to right and the first defined value wins.
+   * @param envVarNameOrNames a name, an async resolver function, or a list of either
+   */
   public async getEnvVarOnDemand(
     envVarNameOrNames: TEnvVarRef | TEnvVarRef[]
   ): Promise<string | undefined> {
@@ -112,23 +157,25 @@ export class Qenv {
   }
 
   /**
-   * Like getEnvVarOnDemand, but throws an error if the env var is not set.
-   * @param envVarNameOrNames 
-   * @returns 
+   * Like getEnvVarOnDemand, but throws when no source provides a value.
+   * @param envVarNameOrNames a name, an async resolver function, or a list of either
    */
   public async getEnvVarOnDemandStrict(
     envVarNameOrNames: TEnvVarRef | TEnvVarRef[]
   ): Promise<string> {
     const value = await this.getEnvVarOnDemand(envVarNameOrNames);
     if (value === undefined) {
-      throw new Error(`Env var ${envVarNameOrNames} is not set!`);
+      throw new Error(`Env var ${this.describeEnvVarRefs(envVarNameOrNames)} is not set!`);
     }
     return value;
   }
 
+  /**
+   * The synchronous counterpart of getEnvVarOnDemand. It resolves names only: an async resolver
+   * function cannot be awaited here, so the function form of TEnvVarRef is not accepted.
+   * @param envVarNameOrNames a name or a list of names
+   */
   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);
@@ -142,7 +189,14 @@ export class Qenv {
     }
   }
 
-  public async getEnvVarOnDemandAsObject(envVarNameOrNames: string | string[]): Promise<any> {
+  /**
+   * Resolves an env var whose value was stored as a base64 encoded object and decodes it. A plain
+   * value is returned as the string it is, so the caller narrows what it gets.
+   * @param envVarNameOrNames a name or a list of names
+   */
+  public async getEnvVarOnDemandAsObject(
+    envVarNameOrNames: string | string[]
+  ): Promise<unknown> {
     const rawValue = await this.getEnvVarOnDemand(envVarNameOrNames);
     if (rawValue && rawValue.startsWith('base64Object:')) {
       const base64Part = rawValue.split('base64Object:')[1];
@@ -156,39 +210,43 @@ export class Qenv {
       return await envVarRefArg();
     }
 
-    const sources = [
-      this.getFromEnvironmentVariable(envVarRefArg),
-      this.getFromEnvYamlOrJsonFile(envVarRefArg),
-      this.getFromDockerSecret(envVarRefArg),
-      this.getFromDockerSecretJson(envVarRefArg)
-    ];
-    
-    for (const value of sources) {
-      if (value !== undefined) {
-        return value;
-      }
-    }
-    
-    return undefined;
+    // a name resolves from synchronous sources only, so both getters share one resolution order
+    return this.tryGetEnvVarSync(envVarRefArg);
   }
 
   private tryGetEnvVarSync(envVarName: string): string | undefined {
-    const sources = [
-      this.getFromEnvironmentVariable(envVarName),
-      this.getFromEnvYamlOrJsonFile(envVarName),
-      this.getFromDockerSecret(envVarName),
-      this.getFromDockerSecretJson(envVarName)
+    // read lazily: a source is only touched once every earlier one came back undefined, so a name
+    // the process environment answers never opens a secret file, and a malformed secret.json only
+    // ever affects the names that actually reach it
+    const sources: Array<() => string | undefined> = [
+      () => this.getFromEnvironmentVariable(envVarName),
+      () => this.getFromEnvYamlOrJsonFile(envVarName),
+      () => this.getFromDockerSecret(envVarName),
+      () => this.getFromDockerSecretJson(envVarName),
     ];
-    
-    for (const value of sources) {
+
+    for (const readSource of sources) {
+      const value = readSource();
       if (value !== undefined) {
         return value;
       }
     }
-    
+
     return undefined;
   }
 
+  /** renders env var references for an error message, naming a resolver function where it has one */
+  private describeEnvVarRefs(envVarNameOrNames: TEnvVarRef | TEnvVarRef[]): string {
+    const envVarRefs = Array.isArray(envVarNameOrNames) ? envVarNameOrNames : [envVarNameOrNames];
+    return envVarRefs
+      .map((envVarRef) =>
+        typeof envVarRef === 'function'
+          ? `${envVarRef.name || 'anonymous'}()`
+          : envVarRef
+      )
+      .join(', ');
+  }
+
   private getFromEnvironmentVariable(envVarName: string): string | undefined {
     return process.env[envVarName];
   }
@@ -212,8 +270,16 @@ export class Qenv {
     }
   }
 
+  /**
+   * the directory Docker mounts secrets into. It is a method so a test can point both secret
+   * readers at a directory it is allowed to create; a process can never write /run/secrets itself.
+   */
+  protected getDockerSecretsDirectoryPath(): string {
+    return '/run/secrets';
+  }
+
   private getFromDockerSecret(envVarName: string): string | undefined {
-    const secretPath = `/run/secrets/${envVarName}`;
+    const secretPath = plugins.path.join(this.getDockerSecretsDirectoryPath(), envVarName);
     if (this.fileExists(secretPath)) {
       return plugins.fs.readFileSync(secretPath, 'utf8');
     }
@@ -221,11 +287,14 @@ export class Qenv {
   }
 
   private getFromDockerSecretJson(envVarName: string): string | undefined {
-    if (this.directoryExists('/run/secrets')) {
-      const availableSecrets = plugins.fs.readdirSync('/run/secrets');
+    const secretsDirectoryPath = this.getDockerSecretsDirectoryPath();
+    if (this.directoryExists(secretsDirectoryPath)) {
+      const availableSecrets = plugins.fs.readdirSync(secretsDirectoryPath);
       for (const secret of availableSecrets) {
         if (secret.includes('secret.json')) {
-          const secretObject = this.readObjectFromFile(`/run/secrets/${secret}`);
+          const secretObject = this.readObjectFromFile(
+            plugins.path.join(secretsDirectoryPath, secret)
+          );
           const value = secretObject[envVarName];
           if (value === undefined) {
             continue;
@@ -240,12 +309,12 @@ export class Qenv {
     return undefined;
   }
 
-  private encodeBase64(data: any): string {
+  private encodeBase64(data: unknown): string {
     const jsonString = JSON.stringify(data);
     return Buffer.from(jsonString).toString('base64');
   }
 
-  private decodeBase64(encodedString: string): any {
+  private decodeBase64(encodedString: string): unknown {
     const decodedString = Buffer.from(encodedString, 'base64').toString('utf-8');
     return JSON.parse(decodedString);
   }
@@ -265,11 +334,13 @@ export class Qenv {
     }
   }
 
-  private readObjectFromFile(filePath: string): TKeyValueObject {
+  private readObjectFromFile(filePath: string): TParsedFileObject {
     const fileString = plugins.fs.readFileSync(filePath, 'utf8');
-    const parsedObject = filePath.endsWith('.json')
+    const parsedObject: unknown = filePath.endsWith('.json')
       ? JSON.parse(fileString)
       : plugins.yaml.parse(fileString);
-    return typeof parsedObject === 'object' && parsedObject !== null ? parsedObject : {};
+    return typeof parsedObject === 'object' && parsedObject !== null
+      ? (parsedObject as TParsedFileObject)
+      : {};
   }
 }