@haskou/ddd-kernel 0.1.1 → 1.0.0

package/dist/adapters/pubsub/amqp/index.d.cts

@@ -1,24 +1,31 @@
-import { a as AmqpMessageBusAdapterOptions } from '../../../NoFailedMessagesError-Kz7CYWpT.cjs';
-export { A as AmqpMessage, C as ConsumerContext, D as DomainEventHandler, I as InvalidDomainEventError, N as NoFailedMessagesError } from '../../../NoFailedMessagesError-Kz7CYWpT.cjs';
+import { a as AmqpMessageBusAdapterOptions, D as DomainEventHandler } from '../../../NoFailedMessagesError-BjxYoKTR.cjs';
+export { A as AmqpMessage, C as ConsumerContext, I as InvalidDomainEventError, N as NoFailedMessagesError } from '../../../NoFailedMessagesError-BjxYoKTR.cjs';
 import { D as DomainEvent } from '../../../DomainEvent-mXWEtr_J.cjs';
 import { C as Constructor } from '../../../Constructor-fyZLLIh8.cjs';
-import { D as DomainEventConsumer } from '../../../DomainEventConsumer-3WBMSSr2.cjs';
-import { D as DomainEventPublisher } from '../../../DomainEventPublisher-8G0lvmdy.cjs';
+import { D as DomainEventConsumer } from '../../../DomainEventConsumer-Bg-bOwmh.cjs';
+import { D as DomainEventPublisher, a as DomainMessageBus } from '../../../DomainMessageBus-OyliPu3Z.cjs';
+import { a as PublisherHook } from '../../../Subscription-4vuAAxax.cjs';
 import '../../../Log-36L3Z84a.cjs';
+import '../../../PublisherHookErrorPolicy-CjouTcSR.cjs';
 import 'amqplib';
+import '../../../MessageBus-BtUXnd0Y.cjs';
+import '../../../HandlerContext-Lm89pSeG.cjs';
+import '../../../ServiceResolver-D2Jz-l_Z.cjs';
 
-declare class AmqpMessageBusAdapter implements DomainEventConsumer, DomainEventPublisher {
+declare class AmqpMessageBusAdapter implements DomainEventConsumer, DomainEventPublisher, DomainMessageBus {
     private readonly options;
     private channelInstance;
     private connection;
     private readonly delayConsumers;
     private exchange;
+    private readonly publisherHookPipeline;
     constructor(options?: AmqpMessageBusAdapterOptions);
     private get dsn();
     private get logger();
     private get maxRetries();
     private get retryDelayInMilliseconds();
     private instanceDomainEvent;
+    private getConsumerContext;
     private handle;
     private handleError;
     private retry;
@@ -33,10 +40,11 @@ declare class AmqpMessageBusAdapter implements DomainEventConsumer, DomainEventP
     private getMessagesToRetry;
     private retryDlxMessage;
     areQueuesBound(): Promise<boolean>;
-    consumeDlx(queueName: string, DomainEventInstance: Constructor<DomainEvent>, handler: (event: DomainEvent) => Promise<void>, messagesToRetry?: number): Promise<void>;
-    consume(queueName: string, bindingKey: string, DomainEventInstance: Constructor<DomainEvent>, exchange: string, handler: (event: DomainEvent) => Promise<void>): Promise<void>;
+    consumeDlx(queueName: string, DomainEventInstance: Constructor<DomainEvent>, handler: DomainEventHandler, messagesToRetry?: number): Promise<void>;
+    consume(queueName: string, bindingKey: string, DomainEventInstance: Constructor<DomainEvent>, exchange: string, handler: DomainEventHandler): Promise<void>;
     publish(domainEvents: DomainEvent[]): Promise<void>;
+    registerPublisherHooks(...hooks: PublisherHook[]): void;
     close(): Promise<void>;
 }
 
-export { AmqpMessageBusAdapterOptions, AmqpMessageBusAdapter as default };
+export { AmqpMessageBusAdapterOptions, DomainEventHandler, AmqpMessageBusAdapter as default };

package/dist/adapters/pubsub/amqp/index.d.ts

@@ -1,24 +1,31 @@
-import { a as AmqpMessageBusAdapterOptions } from '../../../NoFailedMessagesError-0YJKRWPF.js';
-export { A as AmqpMessage, C as ConsumerContext, D as DomainEventHandler, I as InvalidDomainEventError, N as NoFailedMessagesError } from '../../../NoFailedMessagesError-0YJKRWPF.js';
+import { a as AmqpMessageBusAdapterOptions, D as DomainEventHandler } from '../../../NoFailedMessagesError-BLpGI-G4.js';
+export { A as AmqpMessage, C as ConsumerContext, I as InvalidDomainEventError, N as NoFailedMessagesError } from '../../../NoFailedMessagesError-BLpGI-G4.js';
 import { D as DomainEvent } from '../../../DomainEvent-mXWEtr_J.js';
 import { C as Constructor } from '../../../Constructor-fyZLLIh8.js';
-import { D as DomainEventConsumer } from '../../../DomainEventConsumer-B4hkIUmP.js';
-import { D as DomainEventPublisher } from '../../../DomainEventPublisher-DhGgM3f2.js';
+import { D as DomainEventConsumer } from '../../../DomainEventConsumer-BroJmVty.js';
+import { D as DomainEventPublisher, a as DomainMessageBus } from '../../../DomainMessageBus-3jYk7TPw.js';
+import { a as PublisherHook } from '../../../Subscription-vtF0lEHP.js';
 import '../../../Log-36L3Z84a.js';
+import '../../../PublisherHookErrorPolicy-DSsCNE6O.js';
 import 'amqplib';
+import '../../../MessageBus-oQ9BnW84.js';
+import '../../../HandlerContext-DUUExVo3.js';
+import '../../../ServiceResolver-D2Jz-l_Z.js';
 
-declare class AmqpMessageBusAdapter implements DomainEventConsumer, DomainEventPublisher {
+declare class AmqpMessageBusAdapter implements DomainEventConsumer, DomainEventPublisher, DomainMessageBus {
     private readonly options;
     private channelInstance;
     private connection;
     private readonly delayConsumers;
     private exchange;
+    private readonly publisherHookPipeline;
     constructor(options?: AmqpMessageBusAdapterOptions);
     private get dsn();
     private get logger();
     private get maxRetries();
     private get retryDelayInMilliseconds();
     private instanceDomainEvent;
+    private getConsumerContext;
     private handle;
     private handleError;
     private retry;
@@ -33,10 +40,11 @@ declare class AmqpMessageBusAdapter implements DomainEventConsumer, DomainEventP
     private getMessagesToRetry;
     private retryDlxMessage;
     areQueuesBound(): Promise<boolean>;
-    consumeDlx(queueName: string, DomainEventInstance: Constructor<DomainEvent>, handler: (event: DomainEvent) => Promise<void>, messagesToRetry?: number): Promise<void>;
-    consume(queueName: string, bindingKey: string, DomainEventInstance: Constructor<DomainEvent>, exchange: string, handler: (event: DomainEvent) => Promise<void>): Promise<void>;
+    consumeDlx(queueName: string, DomainEventInstance: Constructor<DomainEvent>, handler: DomainEventHandler, messagesToRetry?: number): Promise<void>;
+    consume(queueName: string, bindingKey: string, DomainEventInstance: Constructor<DomainEvent>, exchange: string, handler: DomainEventHandler): Promise<void>;
     publish(domainEvents: DomainEvent[]): Promise<void>;
+    registerPublisherHooks(...hooks: PublisherHook[]): void;
     close(): Promise<void>;
 }
 
-export { AmqpMessageBusAdapterOptions, AmqpMessageBusAdapter as default };
+export { AmqpMessageBusAdapterOptions, DomainEventHandler, AmqpMessageBusAdapter as default };

package/dist/adapters/pubsub/amqp/index.js

@@ -49,6 +49,7 @@ var DependencyInjection = class _DependencyInjection {
   autowire;
   loader;
   container;
+  overrideTokenIds = /* @__PURE__ */ new Map();
   static configure(options) {
     _DependencyInjection.configuredInstance = new _DependencyInjection(options);
     return _DependencyInjection.configuredInstance;
@@ -73,6 +74,16 @@ var DependencyInjection = class _DependencyInjection {
   getServiceClassName(serviceName) {
     return typeof serviceName === "function" ? serviceName.name : void 0;
   }
+  getOverrideId(prefix, token) {
+    const tokenName = this.getServiceClassName(token) ?? String(token);
+    return `ddd-kernel.override.${prefix}.${tokenName}`;
+  }
+  ensureSyntheticService(id, value) {
+    const definition = this.container.register(id);
+    definition.public = true;
+    definition.synthetic = true;
+    this.container.set(id, value);
+  }
   parentMatchesService(parentId, serviceClassName) {
     if (!parentId) {
       return false;
@@ -84,6 +95,26 @@ var DependencyInjection = class _DependencyInjection {
     const serviceName = Buffer.from(serviceId, "base64").toString("utf8");
     return serviceName.endsWith(`__${serviceClassName}__${serviceClassName}`);
   }
+  serviceIdReferencesService(serviceId, serviceClassName) {
+    const serviceName = Buffer.from(serviceId, "base64").toString("utf8");
+    return serviceName.endsWith(`__${serviceClassName}`);
+  }
+  getReferenceId(value) {
+    if (typeof value === "object" && value !== null && "id" in value && typeof value.id === "string") {
+      return value.id;
+    }
+    return void 0;
+  }
+  getDefinitionArgumentReferences(definition) {
+    return [
+      ...definition._args ?? [],
+      ...definition._appendArgs ?? [],
+      ...definition._overrideArgs ?? []
+    ].flatMap((argument) => {
+      const referenceId = this.getReferenceId(argument);
+      return referenceId ? [referenceId] : [];
+    });
+  }
   findConcreteChildServiceId(serviceName) {
     const serviceClassName = this.getServiceClassName(serviceName);
     if (!serviceClassName) {
@@ -114,6 +145,86 @@ var DependencyInjection = class _DependencyInjection {
     );
     return matches[matches.length - 1];
   }
+  findReferencedServiceIds(serviceName) {
+    const serviceClassName = this.getServiceClassName(serviceName);
+    if (!serviceClassName) {
+      return [];
+    }
+    return [
+      ...new Set(
+        [...this.definitions.values()].flatMap(
+          (definition) => this.getDefinitionArgumentReferences(definition)
+        ).filter(
+          (id) => this.serviceIdReferencesService(id, serviceClassName)
+        )
+      )
+    ];
+  }
+  getOverrideTokenIds(token) {
+    const tokenIds = [
+      this.findRegisteredServiceId(token),
+      this.findAliasServiceId(token),
+      ...this.findReferencedServiceIds(token)
+    ].filter((id) => id !== void 0);
+    const existingTokenIds = [...new Set(tokenIds)];
+    if (existingTokenIds.length > 0) {
+      return existingTokenIds;
+    }
+    const overrideTokenId = this.getOverrideId("token", token);
+    this.ensureSyntheticService(overrideTokenId, void 0);
+    return [overrideTokenId];
+  }
+  getOverrideClassServiceId(ClassDefinition) {
+    const registeredServiceId = this.findRegisteredServiceId(ClassDefinition);
+    if (registeredServiceId) {
+      return registeredServiceId;
+    }
+    const overrideClassId = this.getOverrideId("class", ClassDefinition);
+    this.container.register(overrideClassId, ClassDefinition);
+    return overrideClassId;
+  }
+  applyClassOverride(override) {
+    if (!("useClass" in override)) {
+      return;
+    }
+    const tokenIds = this.getOverrideTokenIds(override.token);
+    const classId = this.getOverrideClassServiceId(override.useClass);
+    this.overrideTokenIds.set(override.token, tokenIds[0]);
+    for (const tokenId of tokenIds) {
+      this.container.setAlias(tokenId, classId);
+    }
+  }
+  applyFactoryOverride(override) {
+    if (!("useFactory" in override)) {
+      return;
+    }
+    const tokenIds = this.getOverrideTokenIds(override.token);
+    const factoryId = this.getOverrideId("factory", override.token);
+    this.ensureSyntheticService(factoryId, override.useFactory(this));
+    this.overrideTokenIds.set(override.token, tokenIds[0]);
+    for (const tokenId of tokenIds) {
+      this.container.setAlias(tokenId, factoryId);
+    }
+  }
+  applyValueOverride(override) {
+    if (!("useValue" in override)) {
+      return;
+    }
+    const tokenIds = this.getOverrideTokenIds(override.token);
+    const valueId = this.getOverrideId("value", override.token);
+    this.ensureSyntheticService(valueId, override.useValue);
+    this.overrideTokenIds.set(override.token, tokenIds[0]);
+    for (const tokenId of tokenIds) {
+      this.container.setAlias(tokenId, valueId);
+    }
+  }
+  applyOverrides() {
+    for (const override of this.options.overrides ?? []) {
+      this.applyClassOverride(override);
+      this.applyFactoryOverride(override);
+      this.applyValueOverride(override);
+    }
+  }
   registerParentAliases() {
     for (const [id, definition] of this.definitions.entries()) {
       if (definition._abstract === true || !definition._parent) {
@@ -136,17 +247,22 @@ var DependencyInjection = class _DependencyInjection {
       await this.loader.load(this.options.servicesYamlPath);
     }
     this.registerParentAliases();
+    this.applyOverrides();
     await this.container.compile();
   }
   getService(serviceName) {
-    const childServiceId = this.findConcreteChildServiceId(serviceName);
-    if (childServiceId) {
-      return this.container.get(childServiceId);
+    const overrideTokenId = this.overrideTokenIds.get(serviceName);
+    if (overrideTokenId) {
+      return this.container.get(overrideTokenId);
     }
     const aliasServiceId = this.findAliasServiceId(serviceName);
     if (aliasServiceId) {
       return this.container.get(aliasServiceId);
     }
+    const childServiceId = this.findConcreteChildServiceId(serviceName);
+    if (childServiceId) {
+      return this.container.get(childServiceId);
+    }
     const registeredServiceId = this.findRegisteredServiceId(serviceName);
     if (registeredServiceId) {
       return this.container.get(registeredServiceId);
@@ -194,6 +310,9 @@ var Kernel = class _Kernel {
   static get logger() {
     return _Kernel.getActiveKernel().logger;
   }
+  static get active() {
+    return _Kernel.getActiveKernel();
+  }
   static get rootDirectory() {
     return process.cwd();
   }
@@ -262,13 +381,21 @@ var Kernel = class _Kernel {
   get schedulers() {
     return this.schedulersList;
   }
-  async dependencyInjection() {
-    this.dependencyInjectionInstance = this.dependencyInjectionInstance ?? DependencyInjection.configure({
-      containerBuild: process.env.CONTAINER_BUILD === "true",
-      servicesYamlPath: this.options.servicesYamlPath ?? path2.resolve(_Kernel.configDirectory, "container", "services.yaml"),
-      sourceDirectory: this.options.sourceDirectory ?? _Kernel.sourceDirectory
-    });
+  getDependencyInjectionOptions(options = {}) {
+    return {
+      containerBuild: options.containerBuild ?? process.env.CONTAINER_BUILD === "true",
+      overrides: options.overrides ?? [],
+      servicesYamlPath: options.servicesYamlPath ?? this.options.servicesYamlPath ?? path2.resolve(_Kernel.configDirectory, "container", "services.yaml"),
+      sourceDirectory: options.sourceDirectory ?? this.options.sourceDirectory ?? _Kernel.sourceDirectory
+    };
+  }
+  async dependencyInjection(options = {}) {
+    _Kernel.state.activeKernel = this;
+    this.dependencyInjectionInstance = this.dependencyInjectionInstance ?? DependencyInjection.configure(
+      this.getDependencyInjectionOptions(options)
+    );
     await this.dependencyInjectionInstance.compile();
+    _Kernel.state.activeKernel = this;
   }
   getRoutes() {
     return this.routes;
@@ -351,6 +478,68 @@ var Kernel = class _Kernel {
   }
 };
 
+// src/adapters/pubsub/DefaultPublisherHookErrorPolicy.ts
+var DefaultPublisherHookErrorPolicy = class {
+  handleAfterPublishError(error, context) {
+    void error;
+    void context;
+  }
+  shouldFailAfterPublish(error, context) {
+    void error;
+    void context;
+    return false;
+  }
+};
+
+// src/adapters/pubsub/PublisherHookPipeline.ts
+var PublisherHookPipeline = class {
+  constructor(hooks = [], errorPolicy = new DefaultPublisherHookErrorPolicy()) {
+    this.errorPolicy = errorPolicy;
+    this.hooks.push(...hooks);
+  }
+  errorPolicy;
+  hooks = [];
+  async runAfterPublishHooks(context) {
+    for (const hook of this.hooks) {
+      await this.runAfterPublishHook(hook, context);
+    }
+  }
+  async runAfterPublishHook(hook, context) {
+    try {
+      await hook.afterPublish?.(context);
+    } catch (error) {
+      await this.errorPolicy.handleAfterPublishError(error, context);
+      if (this.errorPolicy.shouldFailAfterPublish(error, context)) {
+        throw error;
+      }
+    }
+  }
+  async runBeforePublishHooks(context) {
+    for (const hook of this.hooks) {
+      await hook.beforePublish?.(context);
+    }
+  }
+  async runPublishErrorHooks(error, context) {
+    for (const hook of this.hooks) {
+      await hook.onPublishError?.(error, context);
+    }
+  }
+  register(...hooks) {
+    this.hooks.push(...hooks);
+  }
+  async run(context, publish) {
+    await this.runBeforePublishHooks(context);
+    try {
+      const result = await publish();
+      await this.runAfterPublishHooks(context);
+      return result;
+    } catch (error) {
+      await this.runPublishErrorHooks(error, context);
+      throw error;
+    }
+  }
+};
+
 // src/adapters/pubsub/amqp/InvalidDomainEventError.ts
 var InvalidDomainEventError = class extends Error {
   constructor(message) {
@@ -372,12 +561,17 @@ var AmqpMessageBusAdapter = class {
   constructor(options = {}) {
     this.options = options;
     this.exchange = options.exchange ?? options.serviceName ?? process.env.SERVICE_NAME ?? "";
+    this.publisherHookPipeline = new PublisherHookPipeline(
+      options.publisherHooks,
+      options.publisherHookErrorPolicy
+    );
   }
   options;
   channelInstance;
   connection;
   delayConsumers = [];
   exchange;
+  publisherHookPipeline;
   get dsn() {
     return this.options.dsn ?? process.env.TRANSPORT_DSN ?? "";
   }
@@ -408,6 +602,15 @@ var AmqpMessageBusAdapter = class {
       message.causation_id
     );
   }
+  getConsumerContext(msg) {
+    return {
+      metadata: {
+        headers: msg.properties.headers ?? {},
+        rawMessage: msg,
+        retries: Number(msg.properties.headers?.retries ?? 0)
+      }
+    };
+  }
   async handle(msg, context) {
     const message = JSON.parse(msg.content.toString());
     this.logger?.info(
@@ -418,7 +621,7 @@ var AmqpMessageBusAdapter = class {
         context.DomainEventInstance,
         message
       );
-      await context.handler(domainEvent);
+      await context.handler(domainEvent, this.getConsumerContext(msg));
     } catch (error) {
       await this.handleError(msg, message, context, error);
     }
@@ -596,7 +799,7 @@ var AmqpMessageBusAdapter = class {
         DomainEventInstance,
         message
       );
-      await handler(domainEvent);
+      await handler(domainEvent, this.getConsumerContext(msg));
       this.logger?.info(`${content} successfully handled.`);
       channel.ack(msg);
     } catch (error) {
@@ -668,14 +871,36 @@ var AmqpMessageBusAdapter = class {
   async publish(domainEvents) {
     const channel = await this.channel();
     for (const event of domainEvents) {
-      channel.publish(
-        this.exchange,
-        event.eventName(),
-        Buffer.from(event.decode()),
-        this.opts(event)
+      await this.publisherHookPipeline.run(
+        {
+          domainEvent: event,
+          message: {
+            metadata: {
+              causationId: event.getCausationId(),
+              correlationId: event.getCorrelationId(),
+              eventId: event.eventId
+            },
+            name: event.eventName(),
+            payload: event.attributes
+          },
+          metadata: {
+            eventId: event.eventId,
+            exchange: this.exchange
+          },
+          topic: event.eventName()
+        },
+        () => channel.publish(
+          this.exchange,
+          event.eventName(),
+          Buffer.from(event.decode()),
+          this.opts(event)
+        )
       );
     }
   }
+  registerPublisherHooks(...hooks) {
+    this.publisherHookPipeline.register(...hooks);
+  }
   async close() {
     await this.channelInstance?.close();
     await this.connection?.close();