@haskou/ddd-kernel 0.1.1 → 1.0.0

package/dist/adapters/pubsub/index.js

@@ -45,6 +45,7 @@ var DependencyInjection = class _DependencyInjection {
   autowire;
   loader;
   container;
+  overrideTokenIds = /* @__PURE__ */ new Map();
   static configure(options) {
     _DependencyInjection.configuredInstance = new _DependencyInjection(options);
     return _DependencyInjection.configuredInstance;
@@ -69,6 +70,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;
@@ -80,6 +91,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) {
@@ -110,6 +141,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) {
@@ -132,17 +243,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);
@@ -190,6 +306,9 @@ var Kernel = class _Kernel {
   static get logger() {
     return _Kernel.getActiveKernel().logger;
   }
+  static get active() {
+    return _Kernel.getActiveKernel();
+  }
   static get rootDirectory() {
     return process.cwd();
   }
@@ -258,13 +377,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;
@@ -347,21 +474,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() {
@@ -370,7 +528,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) {
@@ -379,6 +537,178 @@ var Consumer = class {
 };
 var Consumer_default = Consumer;
 
+// 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";
@@ -401,11 +731,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);
@@ -413,24 +748,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();
@@ -444,13 +797,23 @@ var InMemoryPubSub = class {
       }
     });
   }
+  registerPublisherHooks(...hooks) {
+    this.publisherHookPipeline.register(...hooks);
+  }
 };
 export {
   Consumer,
+  ConsumerMiddlewarePipeline,
+  CorrelationConsumerMiddleware,
+  DefaultPublisherHookErrorPolicy,
+  IdempotencyConsumerMiddleware,
   InMemoryEventBus,
+  InMemoryIdempotencyStore,
   InMemoryPubSub,
   InvalidDomainEventError,
   NoFailedMessagesError,
+  PublisherHookPipeline,
+  RetryConsumerMiddleware,
   Consumer_default as default
 };
 //# sourceMappingURL=index.js.map