@haskou/ddd-kernel 2.0.0 → 2.0.2

package/dist/{RetryPredicate-DNdxY_KR.d.cts → RetryPredicate-BFGD3FUP.d.cts}

@@ -1,4 +1,4 @@
-import { C as ConsumerExecutionContext } from './ShutdownHook-D23WfIIc.cjs';
+import { C as ConsumerExecutionContext } from './ShutdownHook-6-YKfmzG.cjs';
 
 interface IdempotencyStore {
     claim?(key: string): Promise<boolean> | boolean;

package/dist/{RetryPredicate-CD9n6cE8.d.ts → RetryPredicate-CuL59f8-.d.ts}

@@ -1,4 +1,4 @@
-import { C as ConsumerExecutionContext } from './ShutdownHook-CUl7zYwd.js';
+import { C as ConsumerExecutionContext } from './ShutdownHook-dvsrwsQi.js';
 
 interface IdempotencyStore {
     claim?(key: string): Promise<boolean> | boolean;

package/dist/{ServiceClass-BkEHcXDi.d.cts → ServiceClass-Cv5KbUSf.d.cts}

@@ -59,6 +59,7 @@ declare class DependencyInjection implements ServiceResolver {
     private applyFactoryOverride;
     private applyValueOverride;
     private applyOverrides;
+    private processAutowire;
     private registerParentAliases;
     compile(): Promise<void>;
     getService<T>(serviceName: unknown): T;

package/dist/{ServiceClass-Bq_fBC5R.d.ts → ServiceClass-DXDAxvao.d.ts}

@@ -59,6 +59,7 @@ declare class DependencyInjection implements ServiceResolver {
     private applyFactoryOverride;
     private applyValueOverride;
     private applyOverrides;
+    private processAutowire;
     private registerParentAliases;
     compile(): Promise<void>;
     getService<T>(serviceName: unknown): T;

package/dist/{ShutdownHook-D23WfIIc.d.cts → ShutdownHook-6-YKfmzG.d.cts}

@@ -1,6 +1,6 @@
 import { D as DomainEvent } from './DomainEvent-mXWEtr_J.cjs';
 import { DotenvConfigOutput } from 'dotenv';
-import { b as DependencyOverride, D as DependencyInjection, S as ServiceClass } from './ServiceClass-BkEHcXDi.cjs';
+import { b as DependencyOverride, D as DependencyInjection, S as ServiceClass } from './ServiceClass-Cv5KbUSf.cjs';
 import { Initializer, Runtime } from './infrastructure/lifecycle/index.cjs';
 import { a as Scheduler } from './Scheduler-BW-U5Ccg.cjs';
 import { K as KernelLogger } from './KernelLogger-BESOFrpW.cjs';
@@ -102,11 +102,14 @@ declare class Kernel<TEnvironmentSchema extends KernelEnvironmentSchema | undefi
     static get sourceDirectory(): string;
     private static getActiveKernel;
     private static assertRequiredEnvironmentVariable;
+    private static assertRequiredEnvironmentVariableIsNotBlank;
     private static assertEnvironmentVariableChoice;
     private static getEnvironmentVariablesPath;
     private static parseBooleanEnvironmentVariable;
     private static parseNumberEnvironmentVariable;
     private static parseEnvironmentVariable;
+    private static getEnvironmentVariableValue;
+    private static shouldUnsetBlankOptionalEnvironmentVariable;
     private static validateEnvironmentVariables;
     static loadEnvironmentVariables(environment?: string, options?: KernelEnvironmentVariablesOptions<KernelEnvironmentSchema | undefined>): DotenvConfigOutput;
     constructor(options?: KernelOptions<TEnvironmentSchema>);

package/dist/{ShutdownHook-CUl7zYwd.d.ts → ShutdownHook-dvsrwsQi.d.ts}

@@ -1,6 +1,6 @@
 import { D as DomainEvent } from './DomainEvent-mXWEtr_J.js';
 import { DotenvConfigOutput } from 'dotenv';
-import { b as DependencyOverride, D as DependencyInjection, S as ServiceClass } from './ServiceClass-Bq_fBC5R.js';
+import { b as DependencyOverride, D as DependencyInjection, S as ServiceClass } from './ServiceClass-DXDAxvao.js';
 import { Initializer, Runtime } from './infrastructure/lifecycle/index.js';
 import { a as Scheduler } from './Scheduler-BW-U5Ccg.js';
 import { K as KernelLogger } from './KernelLogger-BESOFrpW.js';
@@ -102,11 +102,14 @@ declare class Kernel<TEnvironmentSchema extends KernelEnvironmentSchema | undefi
     static get sourceDirectory(): string;
     private static getActiveKernel;
     private static assertRequiredEnvironmentVariable;
+    private static assertRequiredEnvironmentVariableIsNotBlank;
     private static assertEnvironmentVariableChoice;
     private static getEnvironmentVariablesPath;
     private static parseBooleanEnvironmentVariable;
     private static parseNumberEnvironmentVariable;
     private static parseEnvironmentVariable;
+    private static getEnvironmentVariableValue;
+    private static shouldUnsetBlankOptionalEnvironmentVariable;
     private static validateEnvironmentVariables;
     static loadEnvironmentVariables(environment?: string, options?: KernelEnvironmentVariablesOptions<KernelEnvironmentSchema | undefined>): DotenvConfigOutput;
     constructor(options?: KernelOptions<TEnvironmentSchema>);

package/dist/adapters/index.cjs

@@ -120,6 +120,32 @@ var ConsoleKernelLogger = class {
 var import_dotenv = __toESM(require("dotenv"), 1);
 var import_node_path2 = __toESM(require("path"), 1);
 
+// 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
 var import_fs_extra = __toESM(require("fs-extra"), 1);
 var import_node_dependency_injection = require("node-dependency-injection");
@@ -319,6 +345,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) {
@@ -335,7 +370,7 @@ var DependencyInjection = class _DependencyInjection {
         this.options.servicesYamlPath,
         false
       );
-      await this.autowire.process();
+      await this.processAutowire();
     } else {
       this.loader = new import_node_dependency_injection.YamlFileLoader(this.container);
       await this.loader.load(this.options.servicesYamlPath);
@@ -444,6 +479,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)) {
@@ -466,21 +508,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) {
@@ -498,17 +535,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 {