@haskou/ddd-kernel 0.1.1 → 1.0.0

package/dist/adapters/index.js

@@ -93,6 +93,7 @@ var DependencyInjection = class _DependencyInjection {
   autowire;
   loader;
   container;
+  overrideTokenIds = /* @__PURE__ */ new Map();
   static configure(options) {
     _DependencyInjection.configuredInstance = new _DependencyInjection(options);
     return _DependencyInjection.configuredInstance;
@@ -117,6 +118,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;
@@ -128,6 +139,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) {
@@ -158,6 +189,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) {
@@ -180,17 +291,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);
@@ -238,6 +354,9 @@ var Kernel = class _Kernel {
   static get logger() {
     return _Kernel.getActiveKernel().logger;
   }
+  static get active() {
+    return _Kernel.getActiveKernel();
+  }
   static get rootDirectory() {
     return process.cwd();
   }
@@ -306,13 +425,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;
@@ -395,21 +522,52 @@ var Kernel = class _Kernel {
   }
 };
 
+// src/adapters/pubsub/ConsumerMiddlewarePipeline.ts
+var ConsumerMiddlewarePipeline = class {
+  constructor(middlewares) {
+    this.middlewares = middlewares;
+  }
+  middlewares;
+  async run(event, context, handler, index) {
+    const middleware = this.middlewares[index];
+    if (!middleware) {
+      await handler();
+      return;
+    }
+    await middleware.handle(
+      event,
+      () => this.run(event, context, handler, index + 1),
+      context
+    );
+  }
+  async execute(event, context, handler) {
+    await this.run(event, context, handler, 0);
+  }
+};
+
 // src/adapters/pubsub/Consumer.ts
 var Consumer = class {
   constructor(consumer) {
     this.consumer = consumer;
   }
   consumer;
-  async runMiddleware(event, middlewares, index) {
-    const middleware = middlewares[index];
-    if (!middleware) {
-      await this.handler(event);
-      return;
-    }
-    await middleware.handle(
+  async runMiddleware(event, consumerContext) {
+    const pipeline = new ConsumerMiddlewarePipeline(Kernel.consumerMiddleware);
+    const metadata = consumerContext?.metadata ?? {};
+    await pipeline.execute(
       event,
-      () => this.runMiddleware(event, middlewares, index + 1)
+      {
+        causationId: event.getCausationId(),
+        correlationId: event.getCorrelationId(),
+        eventId: event.eventId,
+        eventName: this.eventName,
+        exchange: this.exchange,
+        kernel: Kernel.active,
+        metadata,
+        queueName: this.queueName,
+        rawMessage: metadata.rawMessage
+      },
+      () => this.handler(event)
     );
   }
   async init() {
@@ -418,7 +576,7 @@ var Consumer = class {
       this.eventName,
       this.domainEvent,
       this.exchange,
-      (event) => this.runMiddleware(event, Kernel.consumerMiddleware, 0)
+      (event, context) => this.runMiddleware(event, context)
     );
   }
   get(service) {
@@ -426,6 +584,178 @@ var Consumer = class {
   }
 };
 
+// src/adapters/pubsub/CorrelationConsumerMiddleware.ts
+var CorrelationConsumerMiddleware = class {
+  constructor(options = {}) {
+    this.options = options;
+  }
+  options;
+  async handle(event, next, context) {
+    const correlationId = this.options.correlationId?.(event, context) ?? context.correlationId;
+    const causationId = this.options.causationId?.(event, context) ?? context.causationId;
+    if (correlationId) {
+      event.withCorrelationId(correlationId);
+    }
+    if (causationId) {
+      event.withCausationId(causationId);
+    }
+    await next();
+  }
+};
+
+// 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/IdempotencyConsumerMiddleware.ts
+var IdempotencyConsumerMiddleware = class {
+  constructor(options) {
+    this.options = options;
+  }
+  options;
+  async handleClaimedKey(key, next) {
+    const claimed = await this.options.store.claim?.(key);
+    if (!claimed) {
+      return;
+    }
+    try {
+      await next();
+      await (this.options.store.commit?.(key) ?? this.options.store.mark(key));
+    } catch (error) {
+      await this.options.store.release?.(key);
+      throw error;
+    }
+  }
+  async handleLegacyKey(key, next) {
+    if (await this.options.store.has(key)) {
+      return;
+    }
+    await next();
+    await this.options.store.mark(key);
+  }
+  async handle(event, next, context) {
+    const key = this.options.key?.(event, context) ?? context.eventId;
+    if (this.options.store.claim) {
+      await this.handleClaimedKey(key, next);
+    } else {
+      await this.handleLegacyKey(key, next);
+    }
+  }
+};
+
+// src/adapters/pubsub/InMemoryIdempotencyStore.ts
+var InMemoryIdempotencyStore = class {
+  claimedKeys = /* @__PURE__ */ new Set();
+  handledKeys = /* @__PURE__ */ new Set();
+  claim(key) {
+    if (this.handledKeys.has(key) || this.claimedKeys.has(key)) {
+      return false;
+    }
+    this.claimedKeys.add(key);
+    return true;
+  }
+  commit(key) {
+    this.claimedKeys.delete(key);
+    this.handledKeys.add(key);
+  }
+  release(key) {
+    this.claimedKeys.delete(key);
+  }
+  has(key) {
+    return this.handledKeys.has(key);
+  }
+  mark(key) {
+    this.handledKeys.add(key);
+  }
+};
+
+// 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/RetryConsumerMiddleware.ts
+var RetryConsumerMiddleware = class {
+  constructor(options) {
+    this.options = options;
+  }
+  options;
+  async delay(attempt, error, context) {
+    const delayInMilliseconds = typeof this.options.delay === "function" ? await this.options.delay(attempt, error, context) : this.options.delay ?? 0;
+    if (delayInMilliseconds > 0) {
+      await new Promise((resolve) => setTimeout(resolve, delayInMilliseconds));
+    }
+  }
+  async handle(event, next, context) {
+    for (let attempt = 1; attempt <= this.options.maxAttempts; attempt++) {
+      try {
+        await next();
+        return;
+      } catch (error) {
+        const canRetry = attempt < this.options.maxAttempts && await (this.options.shouldRetry?.(error, attempt, context) ?? true);
+        if (!canRetry) {
+          throw error;
+        }
+        await this.options.onRetry?.(error, attempt, context);
+        await this.delay(attempt, error, context);
+      }
+    }
+  }
+};
+
 // src/adapters/pubsub/amqp/AmqpMessageBusAdapter.ts
 import amqplib from "amqplib";
 import { randomUUID } from "crypto";
@@ -448,11 +778,16 @@ var NoFailedMessagesError = class extends Error {
 
 // src/adapters/pubsub/in-memory/InMemoryEventBus.ts
 var InMemoryEventBus = class {
-  constructor(context) {
+  constructor(context, publisherHooks = [], publisherHookErrorPolicy) {
     this.context = context;
+    this.publisherHookPipeline = new PublisherHookPipeline(
+      publisherHooks,
+      publisherHookErrorPolicy
+    );
   }
   context;
   handlers = /* @__PURE__ */ new Map();
+  publisherHookPipeline;
   subscribe(name, handler) {
     const handlers = this.handlers.get(name) ?? [];
     handlers.push(handler);
@@ -460,24 +795,42 @@ var InMemoryEventBus = class {
   }
   async publish(event) {
     const handlers = this.handlers.get(event.name) ?? [];
-    for (const handler of handlers) {
-      await handler(event, this.context);
-    }
+    await this.publisherHookPipeline.run(
+      { message: event, metadata: event.metadata ?? {}, topic: event.name },
+      async () => {
+        for (const handler of handlers) {
+          await handler(event, this.context);
+        }
+      }
+    );
+  }
+  registerPublisherHooks(...hooks) {
+    this.publisherHookPipeline.register(...hooks);
   }
 };
 
 // src/adapters/pubsub/in-memory/InMemoryPubSub.ts
 var InMemoryPubSub = class {
-  constructor(context) {
+  constructor(context, publisherHooks = [], publisherHookErrorPolicy) {
     this.context = context;
+    this.publisherHookPipeline = new PublisherHookPipeline(
+      publisherHooks,
+      publisherHookErrorPolicy
+    );
   }
   context;
   consumers = /* @__PURE__ */ new Map();
+  publisherHookPipeline;
   async publish(topic, message) {
     const consumers = this.consumers.get(topic) ?? /* @__PURE__ */ new Set();
-    for (const consumer of consumers) {
-      await consumer(message, this.context);
-    }
+    await this.publisherHookPipeline.run(
+      { message, metadata: message.metadata ?? {}, topic },
+      async () => {
+        for (const consumer of consumers) {
+          await consumer(message, this.context);
+        }
+      }
+    );
   }
   subscribe(topic, consumer) {
     const consumers = this.consumers.get(topic) ?? /* @__PURE__ */ new Set();
@@ -491,31 +844,100 @@ var InMemoryPubSub = class {
       }
     });
   }
+  registerPublisherHooks(...hooks) {
+    this.publisherHookPipeline.register(...hooks);
+  }
 };
 
 // src/adapters/ui/express/ExpressKernelServer.ts
-import { createExpressServer } from "routing-controllers";
+import { createRequire } from "module";
+import path3 from "path";
 var ExpressKernelServer = class {
   constructor(options) {
     this.options = options;
+    this.afterControllersHooks = this.copy(options.afterControllersHooks);
+    this.beforeControllersHooks = this.copy(options.beforeControllersHooks);
+    this.controllers = this.copy(options.controllers);
+    this.errorHandlers = this.copy(options.errorHandlers);
+    this.hooks = this.copy(options.hooks);
+    this.middlewares = this.copy(options.middlewares);
+    this.postControllerMiddlewares = this.copy(
+      options.postControllerMiddlewares
+    );
+    this.preControllerMiddlewares = this.copy(options.preControllerMiddlewares);
+    this.staticHooks = this.copy(options.staticHooks);
+    this.swaggerHooks = this.copy(options.swaggerHooks);
   }
   options;
+  applicationRequire = createRequire(
+    path3.resolve(process.cwd(), "package.json")
+  );
+  afterControllersHooks;
   appInstance;
+  beforeControllersHooks;
+  controllers;
+  errorHandlers;
+  hooks;
+  middlewares;
+  postControllerMiddlewares;
+  preControllerMiddlewares;
   serverInstance;
-  registerErrorHandlers(app) {
-    const handlers = this.options.errorHandlers ?? [this.defaultErrorHandler()];
+  staticHooks;
+  swaggerHooks;
+  copy(items) {
+    return [...items ?? []];
+  }
+  configureControllerContainer() {
+    const { useContainer } = this.getRoutingControllers();
+    useContainer(
+      {
+        /* c8 ignore next */
+        get: (ClassDefinition) => this.options.kernel.di.getService(ClassDefinition)
+      },
+      {
+        fallback: true,
+        fallbackOnErrors: true
+      }
+    );
+  }
+  getExpress() {
+    return this.applicationRequire("express");
+  }
+  getRoutingControllers() {
+    return this.applicationRequire("routing-controllers");
+  }
+  applyErrorHandlers(app) {
+    const handlers = this.errorHandlers.length > 0 ? this.errorHandlers : [this.defaultErrorHandler()];
     for (const handler of handlers) {
       app.use(handler);
     }
   }
   defaultErrorHandler() {
-    return (error, request, response) => {
+    return (error, request, response, next) => {
+      void next;
       void request;
       response.status(500).json({
         error: error instanceof Error ? error.message : String(error)
       });
     };
   }
+  async runHooks(hooks, app) {
+    for (const hook of hooks) {
+      await hook(app);
+    }
+  }
+  async runPhaseHooks(phase, app) {
+    for (const hook of this.hooks) {
+      if (hook.phase === phase) {
+        await hook.handle(app);
+      }
+    }
+  }
+  applyMiddlewares(app, middlewares) {
+    for (const middleware of middlewares) {
+      app.use(middleware);
+    }
+  }
   get app() {
     if (!this.appInstance) {
       throw new Error("HTTP server is not running.");
@@ -528,6 +950,11 @@ var ExpressKernelServer = class {
     }
     return this.serverInstance;
   }
+  assertServerIsNotRunning() {
+    if (this.serverInstance) {
+      throw new Error("HTTP server is already running.");
+    }
+  }
   close() {
     if (!this.serverInstance) {
       return Promise.resolve();
@@ -544,15 +971,74 @@ var ExpressKernelServer = class {
       });
     });
   }
-  run() {
-    const app = createExpressServer({
-      controllers: this.options.kernel.getRoutes(),
+  registerAfterControllersHooks(...hooks) {
+    this.assertServerIsNotRunning();
+    this.afterControllersHooks?.push(...hooks);
+    return this;
+  }
+  registerBeforeControllersHooks(...hooks) {
+    this.assertServerIsNotRunning();
+    this.beforeControllersHooks?.push(...hooks);
+    return this;
+  }
+  registerControllers(...controllers) {
+    this.assertServerIsNotRunning();
+    this.controllers.push(...controllers);
+    return this;
+  }
+  registerErrorHandlers(...handlers) {
+    this.assertServerIsNotRunning();
+    this.errorHandlers.push(...handlers);
+    return this;
+  }
+  registerHooks(...hooks) {
+    this.assertServerIsNotRunning();
+    this.hooks.push(...hooks);
+    return this;
+  }
+  registerMiddlewares(...middlewares) {
+    this.assertServerIsNotRunning();
+    this.middlewares.push(...middlewares);
+    return this;
+  }
+  registerPostControllerMiddlewares(...middlewares) {
+    this.assertServerIsNotRunning();
+    this.postControllerMiddlewares.push(...middlewares);
+    return this;
+  }
+  registerPreControllerMiddlewares(...middlewares) {
+    this.assertServerIsNotRunning();
+    this.preControllerMiddlewares.push(...middlewares);
+    return this;
+  }
+  async run() {
+    if (this.serverInstance) {
+      throw new Error("HTTP server is already running.");
+    }
+    const controllers = [
+      ...this.options.kernel.getRoutes(),
+      ...this.controllers
+    ];
+    const express = this.getExpress();
+    const { useExpressServer } = this.getRoutingControllers();
+    const app = express();
+    this.applyMiddlewares(app, this.middlewares);
+    this.applyMiddlewares(app, this.preControllerMiddlewares);
+    await this.runHooks(this.beforeControllersHooks, app);
+    await this.runPhaseHooks("beforeControllers", app);
+    this.configureControllerContainer();
+    useExpressServer(app, {
+      ...this.options.routingControllersOptions,
+      controllers,
       routePrefix: this.options.routePrefix
     });
-    for (const middleware of this.options.middlewares ?? []) {
-      app.use(middleware);
-    }
-    this.registerErrorHandlers(app);
+    this.applyMiddlewares(app, this.postControllerMiddlewares);
+    await this.runHooks(this.afterControllersHooks, app);
+    await this.runPhaseHooks("afterControllers", app);
+    await this.runHooks(this.swaggerHooks, app);
+    await this.runHooks(this.staticHooks, app);
+    await this.runPhaseHooks("beforeErrors", app);
+    this.applyErrorHandlers(app);
     this.appInstance = app;
     return new Promise((resolve) => {
       this.serverInstance = app.listen(this.options.port ?? 3e3, () => {
@@ -562,6 +1048,134 @@ var ExpressKernelServer = class {
   }
 };
 
+// src/adapters/ui/express/HttpErrorHandler.ts
+import {
+  HttpError
+} from "routing-controllers";
+
+// src/contracts/ui/HttpRouteStatusEnum.ts
+var HttpRouteStatusEnum = {
+  BAD_REQUEST: 400,
+  CONFLICT: 409,
+  CREATED: 201,
+  DEPRECATED: 299,
+  FORBIDDEN: 403,
+  INTERNAL_SERVER_ERROR: 500,
+  NO_CONTENT: 204,
+  NOT_FOUND: 404,
+  OK: 200,
+  PAYLOAD_TOO_LARGE: 413,
+  SERVICE_UNAVAILABLE: 503,
+  TOO_MANY_REQUESTS: 429,
+  UNAUTHORIZED: 401,
+  UNPROCESSABLE_ENTITY: 422
+};
+
+// src/adapters/ui/express/HttpErrorHandler.ts
+var HttpErrorHandler = class {
+  constructor(options = {}) {
+    this.options = options;
+    this.handlers = options.handlers ?? [];
+    this.exposeUnhandledErrorsIn = options.exposeUnhandledErrorsIn ?? [
+      "local",
+      "test"
+    ];
+  }
+  options;
+  handlers;
+  exposeUnhandledErrorsIn;
+  formatValidationErrors(errors) {
+    return errors.flatMap((error) => {
+      if (error.children && error.children.length > 0) {
+        return this.formatValidationErrors(error.children);
+      }
+      return [
+        {
+          details: error.constraints,
+          property: error.property,
+          value: error.value
+        }
+      ];
+    });
+  }
+  getErrorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+  }
+  getHttpStatus(error) {
+    return error.httpCode ?? error.statusCode ?? error.status;
+  }
+  isPayloadTooLargeError(error) {
+    return error.type === "entity.too.large" || this.getHttpStatus(error) === HttpRouteStatusEnum.PAYLOAD_TOO_LARGE;
+  }
+  logUnhandledError(error) {
+    this.options.logger?.error(`Unhandled error: ${error.message}`);
+    this.options.logger?.debug(error.stack ?? "No stack trace available");
+  }
+  handleSyntaxError(error, response) {
+    if (!(error instanceof SyntaxError)) {
+      return false;
+    }
+    response.status(HttpRouteStatusEnum.BAD_REQUEST).json({
+      code: "SyntaxError",
+      message: "Malformed JSON"
+    });
+    return true;
+  }
+  handlePayloadTooLargeError(error, response) {
+    if (!this.isPayloadTooLargeError(error)) {
+      return false;
+    }
+    response.status(HttpRouteStatusEnum.PAYLOAD_TOO_LARGE).json({
+      code: "PayloadTooLargeError",
+      httpStatus: HttpRouteStatusEnum.PAYLOAD_TOO_LARGE,
+      message: "Request entity too large."
+    });
+    return true;
+  }
+  handleHttpError(error, response) {
+    const httpError = error;
+    const httpStatus = this.getHttpStatus(httpError);
+    if (!httpStatus && !(error instanceof HttpError)) {
+      return false;
+    }
+    response.status(httpStatus ?? HttpRouteStatusEnum.INTERNAL_SERVER_ERROR).json({
+      code: error.name,
+      errors: this.formatValidationErrors(
+        error.errors ?? []
+      ),
+      httpStatus: httpStatus ?? HttpRouteStatusEnum.INTERNAL_SERVER_ERROR,
+      message: error.message
+    });
+    return true;
+  }
+  handleUnhandledError(error, response) {
+    if (this.exposeUnhandledErrorsIn.includes(process.env.NODE_ENV ?? "")) {
+      this.logUnhandledError(error);
+    }
+    response.status(HttpRouteStatusEnum.INTERNAL_SERVER_ERROR).json({
+      code: error.constructor.name || String(HttpRouteStatusEnum.INTERNAL_SERVER_ERROR),
+      message: error.message || "Unknown error"
+    });
+  }
+  error(error, request, response, next) {
+    void request;
+    const handlers = [
+      this.handleSyntaxError.bind(this),
+      this.handlePayloadTooLargeError.bind(this),
+      ...this.handlers,
+      this.handleHttpError.bind(this)
+    ];
+    if (handlers.some((handler) => handler(error, response))) {
+      return;
+    }
+    void next;
+    this.handleUnhandledError(error, response);
+  }
+  handle = (error, request, response, next) => {
+    this.error(error, request, response, next);
+  };
+};
+
 // src/adapters/ui/express/RoutePrefix.ts
 var RoutePrefix = class _RoutePrefix {
   value;
@@ -596,13 +1210,21 @@ var Route = class {
 export {
   ConsoleKernelLogger,
   Consumer,
+  ConsumerMiddlewarePipeline,
+  CorrelationConsumerMiddleware,
+  DefaultPublisherHookErrorPolicy,
   ExpressKernelServer,
+  HttpErrorHandler,
+  IdempotencyConsumerMiddleware,
   InMemoryEventBus,
+  InMemoryIdempotencyStore,
   InMemoryPubSub,
   InMemoryRepository,
   InvalidDomainEventError,
   MongoRepository,
   NoFailedMessagesError,
+  PublisherHookPipeline,
+  RetryConsumerMiddleware,
   Route,
   RoutePrefix
 };