@spinajs/configuration 2.0.557 → 3.0.1

package/lib/cjs/configuration.js

@@ -1,10 +1,43 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
 var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
     var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
     if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
     else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 var __metadata = (this && this.__metadata) || function (k, v) {
     if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 };
@@ -29,13 +62,77 @@ const configuration_common_1 = require("@spinajs/configuration-common");
 const di_1 = require("@spinajs/di");
 const exception_js_1 = require("./exception.js");
 const util_js_1 = require("./util.js");
-const configuration_js_1 = __importDefault(require("./config/configuration.js"));
+const configuration_js_1 = __importStar(require("./config/configuration.js"));
 require("./sources.js");
 const ajv_merge_patch_1 = __importDefault(require("ajv-merge-patch"));
 const ajv_formats_1 = __importDefault(require("ajv-formats"));
 const ajv_keywords_1 = __importDefault(require("ajv-keywords"));
 const PROTOCOL_REGEXP = /^([a-zA-Z0-9\-]+:\/\/)+(.+)$/gm;
 const COMMON_WEB_PROTOCOLS = ['http://', 'https://', 'ws://', 'wss://', 'ftp://', 'ftps://', 'file://', 'data://', 'blob://', 'mailto:'];
+// A Configuration whose check ran but which DI has not cached yet (the microtasks after resolve() returns), by container.
+const CHECKED = new WeakMap();
+// The target of each lazy-var proxy load() builds, by proxy: copying a proxy property by property would load every var.
+const LAZY_TARGETS = new WeakMap();
+// Set while Ajv validates the stored value in place: it writes coerced values back through the proxies.
+let keepUnresolvedVars = false;
+const UNSAFE_PATH_SEGMENTS = new Set(['__proto__', 'constructor', 'prototype']);
+// _.set skips these keys, but _.get resolves them, so merge() into `__proto__` would write to Object.prototype.
+function assertSafePath(path) {
+    const unsafe = lodash_1.default.toPath(path).find((s) => UNSAFE_PATH_SEGMENTS.has(s));
+    if (unsafe !== undefined)
+        throw new exceptions_1.InvalidArgument(`Configuration path '${lodash_1.default.toPath(path).join('.')}' contains the reserved segment '${unsafe}'`);
+}
+const isUnresolved = (v) => v instanceof configuration_common_1.ConfigVar && (v.get() ?? null) === null;
+function withLazyVars(obj) {
+    const proxy = new Proxy(obj, {
+        get: (o, prop) => (o[prop] instanceof configuration_common_1.ConfigVar ? o[prop].get() : o[prop]),
+        set: (o, prop, value) => {
+            // A var that is not ready yet reads as null; its coercion ('' for a string) must not replace it for good.
+            if (!(keepUnresolvedVars && isUnresolved(o[prop])))
+                o[prop] = value;
+            return true;
+        },
+    });
+    LAZY_TARGETS.set(proxy, obj);
+    return proxy;
+}
+// A copy that validates as the stored value does: behind a copied lazy-var proxy only the vars the schema reads load,
+// and a class instance (a ConfigVar, one with #private fields a copy would lack) is kept by reference.
+function copyForCheck(value) {
+    return lodash_1.default.cloneDeepWith(value, function copy(v) {
+        const target = typeof v === 'object' && v !== null ? LAZY_TARGETS.get(v) : undefined;
+        if (target)
+            return withLazyVars(lodash_1.default.cloneDeepWith(target, copy));
+        if (Object.prototype.toString.call(v) === '[object Object]' && !lodash_1.default.isPlainObject(v))
+            return v;
+        return undefined;
+    });
+}
+const decodePointer = (segment) => segment.replace(/~1/g, '/').replace(/~0/g, '~');
+// Ajv tags the sub-errors of a propertyNames check with `propertyName`; the check itself reports the key in `params`.
+const isNameError = (e) => e.propertyName !== undefined;
+const keyOf = (e) => {
+    const p = e.params;
+    return p.missingProperty ?? p.additionalProperty ?? p.propertyName;
+};
+function toViolations(module, schema, errors) {
+    const violations = [];
+    for (const e of errors) {
+        if (isNameError(e))
+            continue;
+        const segments = e.instancePath.split('/').filter((p) => p !== '').map(decodePointer);
+        const key = keyOf(e);
+        if (key !== undefined)
+            segments.push(String(key));
+        let message = e.message ?? e.keyword;
+        if (e.keyword === 'propertyNames') {
+            const detail = errors.filter((n) => isNameError(n) && n.instancePath === e.instancePath && n.propertyName === key).map((n) => n.message ?? n.keyword);
+            message = `property name is invalid${detail.length ? `: ${detail.join(', ')}` : ''}`;
+        }
+        violations.push({ path: [module, ...segments].join('.'), schema, message });
+    }
+    return violations;
+}
 /**
  * HACK:
  * Becouse of ajv not supporting esm default exports we need to
@@ -65,6 +162,9 @@ let FrameworkConfiguration = class FrameworkConfiguration extends configuration_
          * Loaded & merged configuration
          */
         this.Config = {};
+        /** Schemas applied after boot that refused the loaded value, by schema; a read of their module throws. */
+        this.RefusedModules = new Map();
+        this.Loading = false;
         this.CustomConfigPaths = options?.cfgCustomPaths ?? [];
         this.RunApp = options?.app ?? (0, util_js_1.parseArgv)('--app') ?? '';
         this.AppBaseDir = options?.appBaseDir ?? (0, util_js_1.parseArgv)('--apppath') ?? (0, path_1.join)(process.cwd(), '../apps/');
@@ -77,7 +177,33 @@ let FrameworkConfiguration = class FrameworkConfiguration extends configuration_
      * @param defaultValue - optional, if value at specified path not exists returns default value
      */
     get(path, defaultValue) {
-        return lodash_1.default.get(this.Config, path, defaultValue);
+        if (this.RefusedModules.size !== 0)
+            this.throwIfRefused(path);
+        const value = lodash_1.default.get(this.Config, path, defaultValue);
+        if (value === null && defaultValue !== undefined && this.isUnresolvedVar(path))
+            return defaultValue;
+        return value;
+    }
+    isUnresolvedVar(path) {
+        const segments = lodash_1.default.toPath(path);
+        if (segments.length === 0)
+            return false;
+        const parent = segments.length === 1 ? this.Config : lodash_1.default.get(this.Config, segments.slice(0, -1));
+        const target = typeof parent === 'object' && parent !== null ? LAZY_TARGETS.get(parent) : undefined;
+        return target !== undefined && isUnresolved(target[segments[segments.length - 1]]);
+    }
+    // A schema applied after boot cannot fail the boot; reading the value it refused, or a part of it, must still fail.
+    throwIfRefused(path) {
+        const segments = lodash_1.default.toPath(path);
+        // An empty path names no module (and reads nothing): it must not match every refused one.
+        if (segments.length === 0)
+            return;
+        for (const { module, error } of this.RefusedModules.values()) {
+            const n = Math.min(module.length, segments.length);
+            if (lodash_1.default.isEqual(module.slice(0, n), segments.slice(0, n))) {
+                throw new exception_js_1.InvalidConfiguration(error.message, error.validationExceptions, error.violations);
+            }
+        }
     }
     /**
      * Sets at given path configuration value. Use when you want to override config
@@ -87,7 +213,11 @@ let FrameworkConfiguration = class FrameworkConfiguration extends configuration_
      * @param value - value to set
      */
     set(path, value) {
+        assertSafePath(path);
+        const schemas = this.schemasAt(path);
+        this.checkChange(schemas, path, (root) => lodash_1.default.set(root, path, copyForCheck(value)));
         this.Config = lodash_1.default.set(this.Config, path, value);
+        this.applySchemas(schemas);
     }
     /**
      * Merge existing config value with new options instead overriding
@@ -96,7 +226,11 @@ let FrameworkConfiguration = class FrameworkConfiguration extends configuration_
      * @param value - value to merge
      */
     merge(path, value) {
+        assertSafePath(path);
+        const schemas = this.schemasAt(path);
+        this.checkChange(schemas, path, (root) => lodash_1.default.mergeWith(lodash_1.default.get(root, path), copyForCheck(value), util_js_1.mergeArrays));
         lodash_1.default.mergeWith(this.get(path), value, util_js_1.mergeArrays);
+        this.applySchemas(schemas);
     }
     async resolve() {
         await super.resolve();
@@ -110,48 +244,76 @@ let FrameworkConfiguration = class FrameworkConfiguration extends configuration_
                 throw new exceptions_1.InvalidArgument(`ConfigurationConfigPaths should be an array`);
             }
             this.CustomConfigPaths.forEach((p) => {
-                internal_logger_1.InternalLogger.trace(`Custom config path at: ${p}`, 'Configuration');
+                internal_logger_1.InternalLogger.trace({ path: p }, 'Custom config path at: ${path}', 'Configuration');
             });
         }
         if (this.RunApp) {
-            internal_logger_1.InternalLogger.info(`Run app is ${this.RunApp}`, 'Configuration');
+            internal_logger_1.InternalLogger.info({ runApp: this.RunApp }, 'Run app is ${runApp}', 'Configuration');
         }
-        internal_logger_1.InternalLogger.info(`App base dir is ${this.AppBaseDir}`, 'Configuration');
+        internal_logger_1.InternalLogger.info({ appBaseDir: this.AppBaseDir }, 'App base dir is ${appBaseDir}', 'Configuration');
         this.initValidator();
-        this.applyAppDirs();
-        // add default configuration of this module
-        // so we dont need to import it
-        this.set('configuration', configuration_js_1.default);
         /**
          * Load and validate data from cfg sources
          * in proper order
          */
         this.loadSources();
         await this.load();
-        this.validate();
-        this.configure();
+        try {
+            this.validate();
+            this.configure();
+        }
+        catch (e) {
+            // DI does not cache a Configuration whose resolve failed: a schema registered later must not be checked against it.
+            if (CHECKED.get(this.Container) === this)
+                CHECKED.delete(this.Container);
+            throw e;
+        }
     }
     async mergeSource(sType) {
         const source = this.Container.resolve(sType);
         const sCfg = await source.Load(this);
+        const schemas = sCfg ? lodash_1.default.uniq(Object.keys(sCfg).flatMap((k) => this.schemasAt([k]))) : [];
+        this.checkChange(schemas, [], (root) => lodash_1.default.mergeWith(root, copyForCheck(sCfg), util_js_1.mergeArrays));
         this.Sources.push(source);
         if (sCfg) {
-            lodash_1.default.mergeWith(sCfg, util_js_1.mergeArrays);
+            lodash_1.default.mergeWith(this.Config, sCfg, util_js_1.mergeArrays);
         }
+        this.applySchemas(schemas);
     }
     /**
      * Reloads configuration data
      */
     async load() {
+        const previous = this.Config;
+        this.Loading = true;
+        try {
+            await this.loadTree();
+            // resolve() checks the first load itself.
+            if (this.ValidationSchemas !== undefined)
+                this.checkAll();
+        }
+        catch (e) {
+            this.Config = previous;
+            throw e;
+        }
+        finally {
+            this.Loading = false;
+        }
+    }
+    async loadTree() {
         this.Config = {};
+        this.NamedEnv = this.Env ?? this.Container.get('process.env')?.APP_ENV ?? process.env.NODE_ENV;
         // add env variables to config
-        const env = di_1.DI.get('process.env');
+        const env = this.Container.get('process.env');
+        const appEnv = this.Env ?? env?.APP_ENV ?? process.env.NODE_ENV ?? 'development';
         this.set('process.env', {
             ...process.env,
             ...env,
-            APP_ENV: this.Env ?? env?.APP_ENV ?? process.env.NODE_ENV ?? 'development',
+            APP_ENV: appEnv,
         });
-        internal_logger_1.InternalLogger.info(`APP_ENV set to ${this.get('process.env.APP_ENV')}`, 'Configuration');
+        // Defaults of this module, which sources may override. The flags follow the APP_ENV that selects the config files.
+        lodash_1.default.mergeWith(this.Config, lodash_1.default.cloneDeep(configuration_js_1.default), { configuration: (0, configuration_js_1.buildEnvironmentFlags)({ APP_ENV: appEnv }) }, util_js_1.mergeArrays);
+        internal_logger_1.InternalLogger.info({ appEnv: this.get('process.env.APP_ENV') }, 'APP_ENV set to ${appEnv}', 'Configuration');
         for (const source of this.Sources) {
             const rCfg = await source.Load(this);
             if (rCfg) {
@@ -164,11 +326,11 @@ let FrameworkConfiguration = class FrameworkConfiguration extends configuration_
          * eg. when custom modules have config and dont want to use files
          * eg. in webpack environment
          */
+        // Merged at the root: merge() writes nothing at a key no source defines.
         this.Container.resolve(Array.ofType('__configuration__')).forEach((c) => {
-            Object.keys(c).forEach((k) => {
-                this.merge(k, c[`${k}`]);
-            });
+            lodash_1.default.mergeWith(this.Config, c, util_js_1.mergeArrays);
         });
+        this.applyAppDirs();
         // load config vars from various protocols
         await this.loadProtocolVars();
         /**
@@ -185,14 +347,7 @@ let FrameworkConfiguration = class FrameworkConfiguration extends configuration_
             if (!haveProtoVals) {
                 return obj;
             }
-            return new Proxy(obj, {
-                get: (obj, prop) => {
-                    if (obj[prop] instanceof configuration_common_1.ConfigVar) {
-                        return obj[prop].get();
-                    }
-                    return obj[prop];
-                },
-            });
+            return withLazyVars(obj);
         };
         // omit system config prop couse dir dynamic loading.
         // NOTE: the root object must be wrapped by proxyFunc AFTER merging - spreading
@@ -205,7 +360,7 @@ let FrameworkConfiguration = class FrameworkConfiguration extends configuration_
         });
     }
     async loadProtocolVars() {
-        const configProtocols = await di_1.DI.resolve(Array.ofType(configuration_common_1.ConfigVarProtocol));
+        const configProtocols = await this.Container.resolve(Array.ofType(configuration_common_1.ConfigVarProtocol));
         if (!configProtocols || configProtocols.length === 0) {
             internal_logger_1.InternalLogger.warn(`No configuration protocols registered`, 'Configuration');
             return;
@@ -213,54 +368,55 @@ let FrameworkConfiguration = class FrameworkConfiguration extends configuration_
         // Build protocol map for O(1) lookup
         const protocolMap = new Map();
         configProtocols.forEach((p) => {
-            internal_logger_1.InternalLogger.info(`Registered configuration protocol: ${p.Protocol}`, 'Configuration');
+            internal_logger_1.InternalLogger.info({ protocol: p.Protocol }, 'Registered configuration protocol: ${protocol}', 'Configuration');
             protocolMap.set(p.Protocol, p);
         });
         // Build common web protocol prefix set for fast checking
         const webProtocolSet = new Set(COMMON_WEB_PROTOCOLS.map(p => p.toLowerCase()));
+        const resolveString = async (obj, key, val, currentPath) => {
+            // Quick check: does it contain ://?
+            const protocolIndex = val.indexOf('://');
+            if (protocolIndex === -1) {
+                return;
+            }
+            // Extract potential protocol (everything before ://)
+            const potentialProtocol = val.substring(0, protocolIndex + 3).toLowerCase();
+            // Skip common web protocols using Set lookup (O(1))
+            if (webProtocolSet.has(potentialProtocol)) {
+                return;
+            }
+            // Use regex only if we passed initial checks
+            PROTOCOL_REGEXP.lastIndex = 0;
+            const match = PROTOCOL_REGEXP.exec(val);
+            if (!match) {
+                return;
+            }
+            // O(1) protocol lookup using Map
+            const protocol = protocolMap.get(match[1]);
+            if (!protocol) {
+                internal_logger_1.InternalLogger.warn({ protocol: match[1] }, 'Protocol ${protocol} used in configuration is not registered.', 'Configuration');
+                return;
+            }
+            const fullPath = [...currentPath, key].join('.');
+            try {
+                obj[key] = await protocol.getVar(match[2], this.Config);
+            }
+            catch (err) {
+                internal_logger_1.InternalLogger.error({ error: err, key: fullPath, protocol: protocol.Protocol, value: val }, 'Error loading configuration var for key ${key} using protocol ${protocol}, value: ${value}', 'Configuration');
+            }
+        };
         const iterate = async (obj, currentPath = []) => {
             if (!obj) {
                 return;
             }
             if (Array.isArray(obj)) {
-                await Promise.all(obj.map((c, index) => iterate(c, [...currentPath, `[${index}]`])));
+                await Promise.all(obj.map((c, index) => (typeof c === 'string' ? resolveString(obj, String(index), c, currentPath) : iterate(c, [...currentPath, `[${index}]`]))));
                 return;
             }
             const stringEntries = (0, util_js_1.pickString)(obj);
             const objectEntries = (0, util_js_1.pickObjects)(obj);
             // Process strings in parallel
-            await Promise.all(stringEntries.map(async ([key, val]) => {
-                // Quick check: does it contain ://? 
-                const protocolIndex = val.indexOf('://');
-                if (protocolIndex === -1) {
-                    return;
-                }
-                // Extract potential protocol (everything before ://)
-                const potentialProtocol = val.substring(0, protocolIndex + 3).toLowerCase();
-                // Skip common web protocols using Set lookup (O(1))
-                if (webProtocolSet.has(potentialProtocol)) {
-                    return;
-                }
-                // Use regex only if we passed initial checks
-                PROTOCOL_REGEXP.lastIndex = 0;
-                const match = PROTOCOL_REGEXP.exec(val);
-                if (!match) {
-                    return;
-                }
-                // O(1) protocol lookup using Map
-                const protocol = protocolMap.get(match[1]);
-                if (!protocol) {
-                    internal_logger_1.InternalLogger.warn(`Protocol ${match[1]} used in configuration is not registered.`, 'Configuration');
-                    return;
-                }
-                const fullPath = [...currentPath, key].join('.');
-                try {
-                    obj[key] = await protocol.getVar(match[2], this.Config);
-                }
-                catch (err) {
-                    internal_logger_1.InternalLogger.error(err, `Error loading configuration var for key ${fullPath} using protocol ${protocol.Protocol}, value: ${val}`, 'Configuration');
-                }
-            }));
+            await Promise.all(stringEntries.map(([key, val]) => resolveString(obj, key, val, currentPath)));
             // Process nested objects in parallel
             await Promise.all(objectEntries.map(([key, val]) => iterate(val, [...currentPath, key])));
         };
@@ -282,21 +438,130 @@ let FrameworkConfiguration = class FrameworkConfiguration extends configuration_
         });
     }
     validate() {
-        this.ValidationSchemas.forEach((s) => {
-            const config = this.get(s.$configurationModule);
-            if (!config) {
-                internal_logger_1.InternalLogger.warn(`Cannot validate configuration for module ${s.$configurationModule}, configuration is not set`, 'Configuration');
-                return;
+        this.checkAll();
+        const container = this.Container;
+        CHECKED.set(container, this);
+        container.once('di.resolved.Configuration', () => {
+            if (CHECKED.get(container) === this)
+                CHECKED.delete(container);
+        });
+    }
+    /** The Configuration of `container` that has run its check but is not resolved (cached) yet. */
+    static checkedIn(container) {
+        return CHECKED.get(container);
+    }
+    checkAll() {
+        this.ValidationSchemas = this.schemasOfLineage();
+        const errors = [];
+        const violations = [];
+        for (const s of this.ValidationSchemas) {
+            const r = this.checkModule(s);
+            errors.push(...r.errors);
+            violations.push(...r.violations);
+        }
+        this.throwIfInvalid(errors, violations);
+        this.RefusedModules.clear();
+    }
+    // The registered schemas whose module is at, under or above `path`. None before the boot check, and none while load()
+    // rebuilds the tree: it checks the whole tree once it is complete.
+    schemasAt(path) {
+        if (this.ValidationSchemas === undefined || this.Loading)
+            return [];
+        const target = lodash_1.default.toPath(path);
+        return this.schemasOfLineage().filter((s) => {
+            const module = lodash_1.default.toPath(s.$configurationModule);
+            const n = Math.min(module.length, target.length);
+            return lodash_1.default.isEqual(module.slice(0, n), target.slice(0, n));
+        });
+    }
+    // Runs `change` on a copy of the modules of `schemas` and throws when one of them would become invalid, so that a
+    // refused change is never applied.
+    checkChange(schemas, path, change) {
+        if (schemas.length === 0)
+            return;
+        const top = lodash_1.default.minBy([lodash_1.default.toPath(path), ...schemas.map((s) => lodash_1.default.toPath(s.$configurationModule))], (p) => p.length) ?? [];
+        const root = (top.length === 0 ? copyForCheck(this.Config) : lodash_1.default.set({}, top, copyForCheck(lodash_1.default.get(this.Config, top))));
+        change(root);
+        const errors = [];
+        const violations = [];
+        for (const s of schemas) {
+            const value = lodash_1.default.get(root, s.$configurationModule);
+            if (value === undefined || this.Validator.validate(s, value))
+                continue;
+            const r = this.failureOf(s);
+            errors.push(...r.errors);
+            violations.push(...r.violations);
+        }
+        this.throwIfInvalid(errors, violations);
+    }
+    // Fills the defaults and coercion of the modules a change that passed checkChange() reached.
+    applySchemas(schemas) {
+        for (const s of schemas) {
+            const r = this.checkModule(s);
+            this.throwIfInvalid(r.errors, r.violations);
+            this.RefusedModules.delete((0, util_js_1.schemaNameOf)(s));
+        }
+    }
+    /** Validates one module after boot; a refused module stays refused for reads until a later check passes. */
+    validateModule(s) {
+        const key = (0, util_js_1.schemaNameOf)(s);
+        const r = this.checkModule(s);
+        try {
+            this.throwIfInvalid(r.errors, r.violations);
+        }
+        catch (e) {
+            this.RefusedModules.set(key, { module: lodash_1.default.toPath(s.$configurationModule), error: e });
+            throw e;
+        }
+        this.RefusedModules.delete(key);
+    }
+    throwIfInvalid(errors, violations) {
+        if (violations.length === 0)
+            return;
+        violations.forEach((v) => internal_logger_1.InternalLogger.error({ path: v.path, schema: v.schema, violation: v.message }, 'Invalid configuration at ${path} ( schema ${schema} ): ${violation}', 'Configuration'));
+        throw new exception_js_1.InvalidConfiguration(`Invalid configuration: ${violations.map((v) => `${v.path} ${v.message} ( schema ${v.schema} )`).join('; ')}`, errors, violations);
+    }
+    checkModule(s) {
+        // Not this.get: a refused module is read here to check it again.
+        const config = lodash_1.default.get(this.Config, s.$configurationModule);
+        if (config === undefined) {
+            // An unconfigured module still gets its schema defaults, unless the schema needs values from the app.
+            const empty = {};
+            if (this.Validator.validate(s, empty)) {
+                lodash_1.default.set(this.Config, s.$configurationModule, empty);
             }
-            const result = this.Validator.validate(s, config);
-            if (!result) {
-                // @ts-ignore
-                this.Validator.errors.forEach((ve) => {
-                    internal_logger_1.InternalLogger.error('Invalid configuration ! Message: %s, path: %s, keyword: %s, schemaPath: %s, configuration module: %s', 'Configuration', ve.message, ve.instancePath, ve.keyword, ve.schemaPath, s.$configurationModule);
-                });
-                throw new exception_js_1.InvalidConfiguration('Validation error', this.Validator.errors);
+            else {
+                internal_logger_1.InternalLogger.warn({ module: s.$configurationModule }, 'Cannot validate configuration for module ${module}, configuration is not set', 'Configuration');
             }
-        });
+            return { errors: [], violations: [] };
+        }
+        // Ajv coerces and fills defaults in place, and evaluates `if` before `properties` coerces. Checking the stored value
+        // directly would rewrite a refused value (a null guard's null into 0) so that the next check of it passes; only a
+        // value whose copy passes gets its defaults and coercion.
+        if (this.Validator.validate(s, copyForCheck(config)) && this.validateInPlace(s, config)) {
+            return { errors: [], violations: [] };
+        }
+        return this.failureOf(s);
+    }
+    // The violations of the last failed this.Validator.validate(s, ...) call.
+    failureOf(s) {
+        const errors = this.Validator.errors ?? [];
+        const schema = (0, util_js_1.schemaNameOf)(s);
+        let violations = toViolations(s.$configurationModule, schema, errors);
+        if (violations.length === 0) {
+            // An invalid configuration must never pass, whatever shape Ajv reported.
+            violations = errors.map((e) => ({ path: [s.$configurationModule, ...e.instancePath.split('/').filter((p) => p !== '').map(decodePointer)].join('.'), schema, message: e.message ?? e.keyword }));
+        }
+        return { errors, violations };
+    }
+    validateInPlace(s, config) {
+        keepUnresolvedVars = true;
+        try {
+            return this.Validator.validate(s, config);
+        }
+        finally {
+            keepUnresolvedVars = false;
+        }
     }
     initValidator() {
         const options = {
@@ -313,6 +578,8 @@ let FrameworkConfiguration = class FrameworkConfiguration extends configuration_
             useDefaults: true,
             // The option coerceTypes allows you to have your data types coerced to the types specified in your schema type keywords
             coerceTypes: true,
+            // allow rules across fields, eg. minimum: { $data: '1/min' }
+            $data: true,
         };
         // @ts-ignore
         if (ajv_1.default.default) {
@@ -335,11 +602,17 @@ let FrameworkConfiguration = class FrameworkConfiguration extends configuration_
         // we use $configurationModule keyword to identify
         // to match config module with config schema
         this.Validator.addKeyword('$configurationModule');
-        /**
-         * load all registered configuration json schemas
-         * for config value validation
-         */
-        this.ValidationSchemas = this.Container.get(Array.ofType('__configurationSchema__'), true);
+    }
+    // A child that registers a schema of its own must not hide the schemas of its ancestors.
+    schemasOfLineage() {
+        const found = [];
+        for (let c = this.Container; c; c = c.Parent) {
+            for (const s of (c.Cache.get('__configurationSchema__', false) ?? [])) {
+                if (!found.some((f) => (0, util_js_1.sameSchema)(f, s)))
+                    found.push(s);
+            }
+        }
+        return found;
     }
     dir(toJoin) {
         return (0, path_1.normalize)((0, path_1.join)((0, path_1.resolve)(this.AppBaseDir), toJoin));
@@ -351,8 +624,10 @@ let FrameworkConfiguration = class FrameworkConfiguration extends configuration_
         if (!this.RunApp) {
             return;
         }
-        for (const prop of Object.keys(this.get(['system', 'dirs'], []))) {
-            this.get(['system', 'dirs', prop]).push(this.dir(`/${this.RunApp}/${prop}`));
+        for (const prop of Object.keys(this.get(['system', 'dirs'], {}))) {
+            const dirs = this.get(['system', 'dirs', prop]);
+            if (Array.isArray(dirs))
+                dirs.push(this.dir(`/${this.RunApp}/${prop}`));
         }
     }
     /**
@@ -363,7 +638,7 @@ let FrameworkConfiguration = class FrameworkConfiguration extends configuration_
         for (const prop of Object.keys(this.Config)) {
             const subconfig = this.Config[`${prop}`];
             if (!subconfig) {
-                internal_logger_1.InternalLogger.warn(`Configuration for ${prop} not exists, check configuration file`, 'configuration');
+                internal_logger_1.InternalLogger.warn({ section: prop }, 'Configuration for ${section} not exists, check configuration file', 'configuration');
                 continue;
             }
             if (subconfig.configure && typeof subconfig.configure === 'function') {