@push.rocks/qenv 7.0.0 → 8.1.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.1.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,4 @@
 export * from './qenv.classes.qenv.js';
+export * from './qenv.classes.invalidqenvfileerror.js';
+export * from './qenv.classes.missingqenvfileerror.js';
+export * from './qenv.classes.missingrequiredenvvarserror.js';

package/dist_ts/index.js

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

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

@@ -0,0 +1,21 @@
+/** which rule of the `required:` list a qenv.yml broke */
+export type TQenvInvalidQenvFileReason = 'requiredNotAnArray' | 'requiredEntryNotAString';
+export interface IQenvInvalidQenvFileErrorOptions {
+    qenvFilePathAbsolute: string;
+    reason: TQenvInvalidQenvFileReason;
+    /** the type name of the offending value, never the value itself */
+    invalidValueTypeName: string;
+}
+/**
+ * Thrown when qenv.yml declares a `required:` that qenv cannot read as a list of names. Such a
+ * declaration silently enforced nothing, which is the same fail-open as a missing qenv.yml.
+ * A file without any `required:` key, and one with an empty list, legitimately require nothing
+ * and never reach this error.
+ */
+export declare class QenvInvalidQenvFileError extends Error {
+    readonly code = "QENV_INVALID_QENV_FILE";
+    readonly qenvFilePathAbsolute: string;
+    readonly reason: TQenvInvalidQenvFileReason;
+    readonly invalidValueTypeName: string;
+    constructor(optionsArg: IQenvInvalidQenvFileErrorOptions);
+}

package/dist_ts/qenv.classes.invalidqenvfileerror.js

@@ -0,0 +1,25 @@
+const reasonDescriptions = {
+    requiredNotAnArray: (typeNameArg) => `"required:" is of type ${typeNameArg} instead of a list of environment variable names`,
+    requiredEntryNotAString: (typeNameArg) => `"required:" contains an entry of type ${typeNameArg} instead of an environment variable name`,
+};
+/**
+ * Thrown when qenv.yml declares a `required:` that qenv cannot read as a list of names. Such a
+ * declaration silently enforced nothing, which is the same fail-open as a missing qenv.yml.
+ * A file without any `required:` key, and one with an empty list, legitimately require nothing
+ * and never reach this error.
+ */
+export class QenvInvalidQenvFileError extends Error {
+    constructor(optionsArg) {
+        super(`The qenv.yml at ${optionsArg.qenvFilePathAbsolute} declares an unreadable requirement: ` +
+            `${reasonDescriptions[optionsArg.reason](optionsArg.invalidValueTypeName)}. ` +
+            `Write "required:" as a list of environment variable names, or omit it to require nothing.`);
+        this.code = 'QENV_INVALID_QENV_FILE';
+        this.name = 'QenvInvalidQenvFileError';
+        this.qenvFilePathAbsolute = optionsArg.qenvFilePathAbsolute;
+        this.reason = optionsArg.reason;
+        // only the type is carried and rendered: a malformed qenv.yml can hold a value where a name
+        // belongs, and a value may be a secret
+        this.invalidValueTypeName = optionsArg.invalidValueTypeName;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicWVudi5jbGFzc2VzLmludmFsaWRxZW52ZmlsZWVycm9yLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vdHMvcWVudi5jbGFzc2VzLmludmFsaWRxZW52ZmlsZWVycm9yLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQVVBLE1BQU0sa0JBQWtCLEdBQXdFO0lBQzlGLGtCQUFrQixFQUFFLENBQUMsV0FBVyxFQUFFLEVBQUUsQ0FDbEMsMEJBQTBCLFdBQVcsa0RBQWtEO0lBQ3pGLHVCQUF1QixFQUFFLENBQUMsV0FBVyxFQUFFLEVBQUUsQ0FDdkMseUNBQXlDLFdBQVcsMENBQTBDO0NBQ2pHLENBQUM7QUFFRjs7Ozs7R0FLRztBQUNILE1BQU0sT0FBTyx3QkFBeUIsU0FBUSxLQUFLO0lBTWpELFlBQVksVUFBNEM7UUFDdEQsS0FBSyxDQUNILG1CQUFtQixVQUFVLENBQUMsb0JBQW9CLHVDQUF1QztZQUN2RixHQUFHLGtCQUFrQixDQUFDLFVBQVUsQ0FBQyxNQUFNLENBQUMsQ0FBQyxVQUFVLENBQUMsb0JBQW9CLENBQUMsSUFBSTtZQUM3RSwyRkFBMkYsQ0FDOUYsQ0FBQztRQVZZLFNBQUksR0FBRyx3QkFBd0IsQ0FBQztRQVc5QyxJQUFJLENBQUMsSUFBSSxHQUFHLDBCQUEwQixDQUFDO1FBQ3ZDLElBQUksQ0FBQyxvQkFBb0IsR0FBRyxVQUFVLENBQUMsb0JBQW9CLENBQUM7UUFDNUQsSUFBSSxDQUFDLE1BQU0sR0FBRyxVQUFVLENBQUMsTUFBTSxDQUFDO1FBQ2hDLDRGQUE0RjtRQUM1Rix1Q0FBdUM7UUFDdkMsSUFBSSxDQUFDLG9CQUFvQixHQUFHLFVBQVUsQ0FBQyxvQkFBb0IsQ0FBQztJQUM5RCxDQUFDO0NBQ0YifQ==

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

@@ -0,0 +1,16 @@
+export interface IQenvMissingQenvFileErrorOptions {
+    qenvFilePathAbsolute: string;
+    qenvDir: string;
+}
+/**
+ * Thrown when a Qenv that is set to fail on missing variables finds no qenv.yml at all.
+ * Without the file there is no `required:` list to enforce, so every check would pass by
+ * accident - a deployable that forgot to ship its qenv.yml would look healthy. `code` identifies
+ * the refusal even when two copies of qenv end up in one tree, which makes `instanceof` unreliable.
+ */
+export declare class QenvMissingQenvFileError extends Error {
+    readonly code = "QENV_MISSING_QENV_FILE";
+    readonly qenvFilePathAbsolute: string;
+    readonly qenvDir: string;
+    constructor(optionsArg: IQenvMissingQenvFileErrorOptions);
+}

package/dist_ts/qenv.classes.missingqenvfileerror.js

@@ -0,0 +1,19 @@
+/**
+ * Thrown when a Qenv that is set to fail on missing variables finds no qenv.yml at all.
+ * Without the file there is no `required:` list to enforce, so every check would pass by
+ * accident - a deployable that forgot to ship its qenv.yml would look healthy. `code` identifies
+ * the refusal even when two copies of qenv end up in one tree, which makes `instanceof` unreliable.
+ */
+export class QenvMissingQenvFileError extends Error {
+    constructor(optionsArg) {
+        super(`qenv found no qenv.yml at ${optionsArg.qenvFilePathAbsolute}. It was constructed to fail ` +
+            `on missing required environment variables, and without qenv.yml there is no "required:" ` +
+            `list to enforce, so nothing would be checked. Ship qenv.yml with your deployable, or ` +
+            `construct Qenv with failOnMissing set to false.`);
+        this.code = 'QENV_MISSING_QENV_FILE';
+        this.name = 'QenvMissingQenvFileError';
+        this.qenvFilePathAbsolute = optionsArg.qenvFilePathAbsolute;
+        this.qenvDir = optionsArg.qenvDir;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicWVudi5jbGFzc2VzLm1pc3NpbmdxZW52ZmlsZWVycm9yLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vdHMvcWVudi5jbGFzc2VzLm1pc3NpbmdxZW52ZmlsZWVycm9yLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUtBOzs7OztHQUtHO0FBQ0gsTUFBTSxPQUFPLHdCQUF5QixTQUFRLEtBQUs7SUFLakQsWUFBWSxVQUE0QztRQUN0RCxLQUFLLENBQ0gsNkJBQTZCLFVBQVUsQ0FBQyxvQkFBb0IsK0JBQStCO1lBQ3pGLDBGQUEwRjtZQUMxRix1RkFBdUY7WUFDdkYsaURBQWlELENBQ3BELENBQUM7UUFWWSxTQUFJLEdBQUcsd0JBQXdCLENBQUM7UUFXOUMsSUFBSSxDQUFDLElBQUksR0FBRywwQkFBMEIsQ0FBQztRQUN2QyxJQUFJLENBQUMsb0JBQW9CLEdBQUcsVUFBVSxDQUFDLG9CQUFvQixDQUFDO1FBQzVELElBQUksQ0FBQyxPQUFPLEdBQUcsVUFBVSxDQUFDLE9BQU8sQ0FBQztJQUNwQyxDQUFDO0NBQ0YifQ==

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,82 @@
 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, a QenvMissingQenvFileError when there
+     * is no qenv.yml to read that list from, and a QenvInvalidQenvFileError when the list cannot be
+     * read as names. Pass false to only record the names in `missingEnvVars` and continue.
+     * @throws QenvMissingQenvFileError
+     * @throws QenvInvalidQenvFileError
+     * @throws QenvMissingRequiredEnvVarsError
+     */
     constructor(qenvFileBasePathArg?: string, envFileBasePathArg?: string, failOnMissing?: boolean);
     private initializeFilePaths;
     private loadRequiredEnvVars;
+    /**
+     * Refuses a qenv.yml whose `required:` cannot be read as names: it enforces nothing, which is
+     * the fail-open a missing qenv.yml would be. A caller that opted out of failing keeps running,
+     * but hears the same named reason instead of losing the requirement silently.
+     */
+    private refuseInvalidQenvFile;
+    /** names the type of a value without rendering it: a value in a name's place may be a secret */
+    private describeValueType;
     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 +85,3 @@ export declare class Qenv {
     private directoryExists;
     private readObjectFromFile;
 }
-export {};

package/dist_ts/qenv.classes.qenv.js

@@ -1,14 +1,33 @@
 import * as plugins from './qenv.plugins.js';
+import { QenvInvalidQenvFileError, } from './qenv.classes.invalidqenvfileerror.js';
+import { QenvMissingQenvFileError } from './qenv.classes.missingqenvfileerror.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, a QenvMissingQenvFileError when there
+     * is no qenv.yml to read that list from, and a QenvInvalidQenvFileError when the list cannot be
+     * read as names. Pass false to only record the names in `missingEnvVars` and continue.
+     * @throws QenvMissingQenvFileError
+     * @throws QenvInvalidQenvFileError
+     * @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 = '';
         this.initializeFilePaths(qenvFileBasePathArg, envFileBasePathArg);
-        this.loadRequiredEnvVars();
+        this.loadRequiredEnvVars(failOnMissing);
         this.loadAvailableEnvVars();
         this.checkForMissingEnvVars(failOnMissing);
     }
@@ -37,21 +56,66 @@ 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!');
+    loadRequiredEnvVars(failOnMissing) {
+        if (!this.fileExists(this.qenvFilePathAbsolute)) {
+            if (failOnMissing) {
+                // enforcing without the file that declares what to enforce would pass every check by
+                // accident: a deployable that forgot to ship qenv.yml must be refused by name, not
+                // silently exempted
+                throw new QenvMissingQenvFileError({
+                    qenvFilePathAbsolute: this.qenvFilePathAbsolute,
+                    qenvDir: plugins.path.dirname(this.qenvFilePathAbsolute),
+                });
             }
+            return;
+        }
+        const qenvFile = this.readObjectFromFile(this.qenvFilePathAbsolute);
+        const declaredRequirements = qenvFile['required'];
+        if (declaredRequirements === undefined || declaredRequirements === null) {
+            // a qenv.yml that lists no requirement legitimately requires nothing
+            return;
         }
+        if (!Array.isArray(declaredRequirements)) {
+            this.refuseInvalidQenvFile(failOnMissing, 'requiredNotAnArray', declaredRequirements);
+            return;
+        }
+        const declaredEntries = declaredRequirements;
+        const invalidEntryIndex = declaredEntries.findIndex((entry) => typeof entry !== 'string');
+        if (invalidEntryIndex !== -1) {
+            this.refuseInvalidQenvFile(failOnMissing, 'requiredEntryNotAString', declaredEntries[invalidEntryIndex]);
+        }
+        this.requiredEnvVars.push(...declaredEntries.filter((entry) => typeof entry === 'string'));
+    }
+    /**
+     * Refuses a qenv.yml whose `required:` cannot be read as names: it enforces nothing, which is
+     * the fail-open a missing qenv.yml would be. A caller that opted out of failing keeps running,
+     * but hears the same named reason instead of losing the requirement silently.
+     */
+    refuseInvalidQenvFile(failOnMissing, reason, invalidValue) {
+        const invalidQenvFileError = new QenvInvalidQenvFileError({
+            qenvFilePathAbsolute: this.qenvFilePathAbsolute,
+            reason,
+            invalidValueTypeName: this.describeValueType(invalidValue),
+        });
+        if (failOnMissing) {
+            throw invalidQenvFileError;
+        }
+        this.logger.log('warn', invalidQenvFileError.message);
+    }
+    /** names the type of a value without rendering it: a value in a name's place may be a secret */
+    describeValueType(valueArg) {
+        if (valueArg === null) {
+            return 'null';
+        }
+        return Array.isArray(valueArg) ? 'array' : typeof valueArg;
     }
     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 +124,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 +157,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 +186,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 +203,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 +255,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 +316,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.1.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",