@push.rocks/qenv 8.0.0 → 8.1.0

package/dist_ts/00_commitinfo_data.js

@@ -3,7 +3,7 @@
  */
 export const commitinfo = {
     name: '@push.rocks/qenv',
-    version: '8.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,2 +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,3 +1,5 @@
 export * from './qenv.classes.qenv.js';
+export * from './qenv.classes.invalidqenvfileerror.js';
+export * from './qenv.classes.missingqenvfileerror.js';
 export * from './qenv.classes.missingrequiredenvvarserror.js';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi90cy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLHdCQUF3QixDQUFDO0FBQ3ZDLGNBQWMsK0NBQStDLENBQUMifQ==
+//# 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.qenv.d.ts

@@ -23,13 +23,24 @@ export declare class Qenv {
      * @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.
+     * `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;
     /**

package/dist_ts/qenv.classes.qenv.js

@@ -1,4 +1,6 @@
 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 {
     /**
@@ -6,8 +8,11 @@ export class Qenv {
      * @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.
+     * `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) {
@@ -22,7 +27,7 @@ export class Qenv {
         this.logger = new plugins.smartlog.ConsoleLog();
         this.qenvFilePathAbsolute = '';
         this.initializeFilePaths(qenvFileBasePathArg, envFileBasePathArg);
-        this.loadRequiredEnvVars();
+        this.loadRequiredEnvVars(failOnMissing);
         this.loadAvailableEnvVars();
         this.checkForMissingEnvVars(failOnMissing);
     }
@@ -51,19 +56,59 @@ export class Qenv {
             }
         }
     }
-    loadRequiredEnvVars() {
+    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.logger.log('warn', 'qenv.yml does not contain a "required" Array!');
+            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
@@ -276,4 +321,4 @@ export class Qenv {
             : {};
     }
 }
-//# 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": "8.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",

package/readme.md

@@ -67,6 +67,24 @@ Every listed name is resolved while the `Qenv` instance is constructed. What is
 `availableEnvVars` and, as a string, in `keyValueObject`; what is missing lands in `missingEnvVars`
 and, unless you pass `failOnMissing: false`, makes the constructor throw.
 
+With `failOnMissing` left at its default `true`, the `qenv.yml` itself is part of what is enforced:
+if there is none at the given path, the constructor throws `QenvMissingQenvFileError` and names the
+path it looked at. Without the file there is no `required:` list, so every check would pass by
+accident - a container image that forgot to ship its `qenv.yml` would look healthy while enforcing
+nothing. **Ship `qenv.yml` with your deployable**, next to the code that reads it. A `qenv.yml`
+whose `required:` cannot be read as a list of names - a scalar instead of a list, or an entry that
+is not a name - is refused the same way, with `QenvInvalidQenvFileError`.
+
+A `qenv.yml` that requires nothing is legitimate and constructs: write `required: []`, or leave the
+`required:` key out altogether. Only the file's absence and an unreadable list are refused.
+
+The CLI or library case that reads from wherever it happens to run passes `failOnMissing: false`:
+
+```typescript
+// no qenv.yml expected here - resolve what is there, enforce nothing
+const qenv = new Qenv(process.cwd(), undefined, false);
+```
+
 #### 2. Provide Values (`env.yml` or `env.json`)
 
 For local development, create an `env.yml` or `env.json` file:
@@ -363,8 +381,11 @@ new Qenv(
 )
 ```
 
-Throws `QenvMissingRequiredEnvVarsError` when `failOnMissing` is true and a name listed under
-`required:` is not provided by any source.
+With `failOnMissing` true the constructor throws `QenvMissingQenvFileError` when there is no
+`qenv.yml` at `qenvFileBasePathArg`, `QenvInvalidQenvFileError` when its `required:` cannot be read
+as a list of names, and `QenvMissingRequiredEnvVarsError` when a name listed under `required:` is
+not provided by any source. With `failOnMissing` false the constructor never throws: a missing
+`qenv.yml` is accepted and an unreadable `required:` is logged as a warning.
 
 #### Methods
 
@@ -397,6 +418,29 @@ Thrown by the constructor when `failOnMissing` is true and a required variable h
 | `requiredEnvVars` | `string[]` | Every name listed under `required:` |
 | `qenvFilePathAbsolute` | `string` | The qenv.yml that declared them |
 
+### Class: `QenvMissingQenvFileError`
+
+Thrown by the constructor when `failOnMissing` is true and there is no `qenv.yml` to read the
+`required:` list from.
+
+| Member | Type | Description |
+|--------|------|-------------|
+| `code` | `'QENV_MISSING_QENV_FILE'` | Stable identifier, safe across duplicate installs |
+| `qenvFilePathAbsolute` | `string` | The qenv.yml path that was looked at |
+| `qenvDir` | `string` | The resolved directory that should hold it |
+
+### Class: `QenvInvalidQenvFileError`
+
+Thrown by the constructor when `failOnMissing` is true and `required:` is not a list of names;
+logged as a warning with the same message when `failOnMissing` is false.
+
+| Member | Type | Description |
+|--------|------|-------------|
+| `code` | `'QENV_INVALID_QENV_FILE'` | Stable identifier, safe across duplicate installs |
+| `reason` | `'requiredNotAnArray' \| 'requiredEntryNotAString'` | Which rule the file broke |
+| `invalidValueTypeName` | `string` | The type of the offending value, never the value itself |
+| `qenvFilePathAbsolute` | `string` | The qenv.yml that declared it |
+
 ## 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.

package/ts/00_commitinfo_data.ts

@@ -3,6 +3,6 @@
  */
 export const commitinfo = {
   name: '@push.rocks/qenv',
-  version: '8.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.'
 }

package/ts/index.ts

@@ -1,2 +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/ts/qenv.classes.invalidqenvfileerror.ts

@@ -0,0 +1,43 @@
+/** 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;
+}
+
+const reasonDescriptions: Record<TQenvInvalidQenvFileReason, (typeNameArg: string) => string> = {
+  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 {
+  public readonly code = 'QENV_INVALID_QENV_FILE';
+  public readonly qenvFilePathAbsolute: string;
+  public readonly reason: TQenvInvalidQenvFileReason;
+  public readonly invalidValueTypeName: string;
+
+  constructor(optionsArg: IQenvInvalidQenvFileErrorOptions) {
+    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.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;
+  }
+}

package/ts/qenv.classes.missingqenvfileerror.ts

@@ -0,0 +1,28 @@
+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 class QenvMissingQenvFileError extends Error {
+  public readonly code = 'QENV_MISSING_QENV_FILE';
+  public readonly qenvFilePathAbsolute: string;
+  public readonly qenvDir: string;
+
+  constructor(optionsArg: IQenvMissingQenvFileErrorOptions) {
+    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.name = 'QenvMissingQenvFileError';
+    this.qenvFilePathAbsolute = optionsArg.qenvFilePathAbsolute;
+    this.qenvDir = optionsArg.qenvDir;
+  }
+}

package/ts/qenv.classes.qenv.ts

@@ -1,4 +1,9 @@
 import * as plugins from './qenv.plugins.js';
+import {
+  QenvInvalidQenvFileError,
+  type TQenvInvalidQenvFileReason,
+} from './qenv.classes.invalidqenvfileerror.js';
+import { QenvMissingQenvFileError } from './qenv.classes.missingqenvfileerror.js';
 import { QenvMissingRequiredEnvVarsError } from './qenv.classes.missingrequiredenvvarserror.js';
 
 /**
@@ -36,8 +41,11 @@ export class Qenv {
    * @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.
+   * `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(
@@ -46,7 +54,7 @@ export class Qenv {
     failOnMissing: boolean = true
   ) {
     this.initializeFilePaths(qenvFileBasePathArg, envFileBasePathArg);
-    this.loadRequiredEnvVars();
+    this.loadRequiredEnvVars(failOnMissing);
     this.loadAvailableEnvVars();
     this.checkForMissingEnvVars(failOnMissing);
   }
@@ -81,22 +89,72 @@ export class Qenv {
     }
   }
 
-  private loadRequiredEnvVars() {
+  private loadRequiredEnvVars(failOnMissing: boolean) {
     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.logger.log('warn', 'qenv.yml does not contain a "required" Array!');
+      this.refuseInvalidQenvFile(failOnMissing, 'requiredNotAnArray', declaredRequirements);
       return;
     }
     const declaredEntries: unknown[] = declaredRequirements;
+    const invalidEntryIndex = declaredEntries.findIndex((entry) => typeof entry !== 'string');
+    if (invalidEntryIndex !== -1) {
+      this.refuseInvalidQenvFile(
+        failOnMissing,
+        'requiredEntryNotAString',
+        declaredEntries[invalidEntryIndex]
+      );
+    }
     this.requiredEnvVars.push(
       ...declaredEntries.filter((entry): entry is string => 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.
+   */
+  private refuseInvalidQenvFile(
+    failOnMissing: boolean,
+    reason: TQenvInvalidQenvFileReason,
+    invalidValue: unknown
+  ) {
+    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 */
+  private describeValueType(valueArg: unknown): string {
+    if (valueArg === null) {
+      return 'null';
+    }
+    return Array.isArray(valueArg) ? 'array' : typeof valueArg;
+  }
+
   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