@haskou/ddd-kernel 2.0.1 → 2.0.2

package/dist/adapters/index.js

@@ -66,6 +66,32 @@ var ConsoleKernelLogger = class {
 import dotenv from "dotenv";
 import path2 from "path";
 
+// src/infrastructure/dependency-injection/AutowireWarningFilter.ts
+var AutowireWarningFilter = class {
+  constructor(logger) {
+    this.logger = logger;
+  }
+  logger;
+  isIgnorableAutowireWarning(message) {
+    return message.startsWith(
+      "Autowire: file has export default declaration but no runtime default export:"
+    ) || message.startsWith("Autowire: failed to create definition for undefined:");
+  }
+  warn(message, ...optionalParams) {
+    if (typeof message === "string" && this.isIgnorableAutowireWarning(message)) {
+      this.logger.debug?.(`Ignored ${message}`, ...optionalParams);
+      return;
+    }
+    this.logger.warn(message, ...optionalParams);
+  }
+  info(message, ...optionalParams) {
+    this.logger.info?.(message, ...optionalParams);
+  }
+  debug(message, ...optionalParams) {
+    this.logger.debug?.(message, ...optionalParams);
+  }
+};
+
 // src/infrastructure/dependency-injection/DependencyInjection.ts
 import fs from "fs-extra";
 import {
@@ -270,6 +296,15 @@ var DependencyInjection = class _DependencyInjection {
       this.applyValueOverride(override);
     }
   }
+  async processAutowire() {
+    const previousLogger = this.container.logger;
+    this.container.logger = new AutowireWarningFilter(previousLogger);
+    try {
+      await this.autowire?.process();
+    } finally {
+      this.container.logger = previousLogger;
+    }
+  }
   registerParentAliases() {
     for (const [id, definition] of this.definitions.entries()) {
       if (definition._abstract === true || !definition._parent) {
@@ -286,7 +321,7 @@ var DependencyInjection = class _DependencyInjection {
         this.options.servicesYamlPath,
         false
       );
-      await this.autowire.process();
+      await this.processAutowire();
     } else {
       this.loader = new YamlFileLoader(this.container);
       await this.loader.load(this.options.servicesYamlPath);
@@ -395,6 +430,13 @@ var Kernel = class _Kernel {
       );
     }
   }
+  static assertRequiredEnvironmentVariableIsNotBlank(name, value, schema) {
+    if (schema[name]?.required === true && value.trim() === "") {
+      throw new KernelEnvironmentValidationError(
+        `Blank required environment variable "${name}".`
+      );
+    }
+  }
   static assertEnvironmentVariableChoice(name, value, schema) {
     const choices = schema[name]?.choices;
     if (choices && !choices.includes(value)) {
@@ -417,21 +459,16 @@ var Kernel = class _Kernel {
       return false;
     }
     throw new KernelEnvironmentValidationError(
-      `Environment variable "${name}" must be a boolean.`
+      `Environment variable "${name}" has invalid boolean value "${value}".`
     );
   }
   static parseNumberEnvironmentVariable(name, value) {
-    if (value.trim() === "") {
-      throw new KernelEnvironmentValidationError(
-        `Environment variable "${name}" must be a number.`
-      );
-    }
     const parsedValue = Number(value);
     if (Number.isFinite(parsedValue)) {
       return parsedValue;
     }
     throw new KernelEnvironmentValidationError(
-      `Environment variable "${name}" must be a number.`
+      `Environment variable "${name}" has invalid number value "${value}".`
     );
   }
   static parseEnvironmentVariable(name, value, schema) {
@@ -449,17 +486,42 @@ var Kernel = class _Kernel {
     _Kernel.assertEnvironmentVariableChoice(name, value, schema);
     return value;
   }
+  static getEnvironmentVariableValue(name, definition, schema) {
+    const value = process.env[name];
+    _Kernel.assertRequiredEnvironmentVariable(name, value, schema);
+    if (value !== void 0) {
+      _Kernel.assertRequiredEnvironmentVariableIsNotBlank(name, value, schema);
+    }
+    if (value !== void 0 && value.trim() !== "") {
+      return value;
+    }
+    return definition.defaultValue?.toString();
+  }
+  static shouldUnsetBlankOptionalEnvironmentVariable(name, value, valueOrDefault, schema) {
+    return value !== void 0 && value.trim() === "" && valueOrDefault === void 0 && schema[name]?.required !== true;
+  }
   static validateEnvironmentVariables(schema) {
     const environmentVariables = {};
     for (const [name, definition] of Object.entries(schema)) {
-      const value = process.env[name] ?? definition.defaultValue?.toString();
-      _Kernel.assertRequiredEnvironmentVariable(name, value, schema);
-      if (value !== void 0) {
+      const value = process.env[name];
+      const valueOrDefault = _Kernel.getEnvironmentVariableValue(
+        name,
+        definition,
+        schema
+      );
+      if (valueOrDefault !== void 0) {
         environmentVariables[name] = _Kernel.parseEnvironmentVariable(
           name,
-          value,
+          valueOrDefault,
           schema
         );
+      } else if (_Kernel.shouldUnsetBlankOptionalEnvironmentVariable(
+        name,
+        value,
+        valueOrDefault,
+        schema
+      )) {
+        environmentVariables[name] = void 0;
       }
     }
     return {