@haskou/ddd-kernel 0.1.0

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

@@ -0,0 +1,691 @@
+// src/adapters/pubsub/amqp/AmqpMessageBusAdapter.ts
+import amqplib from "amqplib";
+import { randomUUID } from "crypto";
+
+// src/Kernel.ts
+import path2 from "path";
+
+// src/adapters/kernel/console/ConsoleKernelLogger.ts
+var ConsoleKernelLogger = class {
+  debug(message) {
+    console.debug(message);
+  }
+  error(message) {
+    console.error(message);
+  }
+  info(message) {
+    console.info(message);
+  }
+  warn(message) {
+    console.warn(message);
+  }
+};
+
+// src/infrastructure/dependency-injection/DependencyInjection.ts
+import fs from "fs-extra";
+import {
+  Autowire,
+  ContainerBuilder,
+  ServiceFile,
+  YamlFileLoader
+} from "node-dependency-injection";
+import path from "path";
+var DependencyInjection = class _DependencyInjection {
+  constructor(options = {
+    containerBuild: process.env.CONTAINER_BUILD === "true",
+    servicesYamlPath: path.resolve(
+      process.cwd(),
+      "config",
+      "container",
+      "services.yaml"
+    ),
+    sourceDirectory: path.resolve(process.cwd(), "src")
+  }) {
+    this.options = options;
+    this.container = new ContainerBuilder(false, this.options.sourceDirectory);
+  }
+  options;
+  static configuredInstance;
+  autowire;
+  loader;
+  container;
+  static configure(options) {
+    _DependencyInjection.configuredInstance = new _DependencyInjection(options);
+    return _DependencyInjection.configuredInstance;
+  }
+  static get instance() {
+    if (!_DependencyInjection.configuredInstance) {
+      throw new Error("DependencyInjection has not been configured.");
+    }
+    return _DependencyInjection.configuredInstance;
+  }
+  get definitions() {
+    const container = this.container;
+    return container._definitions || /* @__PURE__ */ new Map();
+  }
+  get aliases() {
+    const container = this.container;
+    return container._alias || /* @__PURE__ */ new Map();
+  }
+  async ensureFolderExists(filePath) {
+    await fs.mkdir(path.dirname(filePath), { recursive: true });
+  }
+  getServiceClassName(serviceName) {
+    return typeof serviceName === "function" ? serviceName.name : void 0;
+  }
+  parentMatchesService(parentId, serviceClassName) {
+    if (!parentId) {
+      return false;
+    }
+    const parentName = Buffer.from(parentId, "base64").toString("utf8");
+    return parentName.endsWith(`__${serviceClassName}__${serviceClassName}`);
+  }
+  serviceIdMatchesService(serviceId, serviceClassName) {
+    const serviceName = Buffer.from(serviceId, "base64").toString("utf8");
+    return serviceName.endsWith(`__${serviceClassName}__${serviceClassName}`);
+  }
+  findConcreteChildServiceId(serviceName) {
+    const serviceClassName = this.getServiceClassName(serviceName);
+    if (!serviceClassName) {
+      return void 0;
+    }
+    const matches = [...this.definitions.entries()].filter(([, definition]) => definition._abstract !== true).filter(
+      ([, definition]) => this.parentMatchesService(definition._parent, serviceClassName)
+    ).map(([id]) => id);
+    return matches[matches.length - 1];
+  }
+  findRegisteredServiceId(serviceName) {
+    const serviceClassName = this.getServiceClassName(serviceName);
+    if (!serviceClassName) {
+      return void 0;
+    }
+    const matches = [...this.definitions.keys()].filter(
+      (id) => this.serviceIdMatchesService(id, serviceClassName)
+    );
+    return matches[matches.length - 1];
+  }
+  findAliasServiceId(serviceName) {
+    const serviceClassName = this.getServiceClassName(serviceName);
+    if (!serviceClassName) {
+      return void 0;
+    }
+    const matches = [...this.aliases.keys()].filter(
+      (id) => this.serviceIdMatchesService(id, serviceClassName)
+    );
+    return matches[matches.length - 1];
+  }
+  registerParentAliases() {
+    for (const [id, definition] of this.definitions.entries()) {
+      if (definition._abstract === true || !definition._parent) {
+        continue;
+      }
+      this.container.setAlias(definition._parent, id);
+    }
+  }
+  async compile() {
+    if (this.options.containerBuild) {
+      await this.ensureFolderExists(this.options.servicesYamlPath);
+      this.autowire = new Autowire(this.container);
+      this.autowire.serviceFile = new ServiceFile(
+        this.options.servicesYamlPath,
+        false
+      );
+      await this.autowire.process();
+    } else {
+      this.loader = new YamlFileLoader(this.container);
+      await this.loader.load(this.options.servicesYamlPath);
+    }
+    this.registerParentAliases();
+    await this.container.compile();
+  }
+  getService(serviceName) {
+    const childServiceId = this.findConcreteChildServiceId(serviceName);
+    if (childServiceId) {
+      return this.container.get(childServiceId);
+    }
+    const aliasServiceId = this.findAliasServiceId(serviceName);
+    if (aliasServiceId) {
+      return this.container.get(aliasServiceId);
+    }
+    const registeredServiceId = this.findRegisteredServiceId(serviceName);
+    if (registeredServiceId) {
+      return this.container.get(registeredServiceId);
+    }
+    return this.container.get(serviceName);
+  }
+};
+
+// src/Kernel.ts
+var Kernel = class _Kernel {
+  constructor(options = {}) {
+    this.options = options;
+    this.loggerInstance = options.logger ?? new ConsoleKernelLogger();
+    this.dependencyInjectionInstance = options.di;
+    _Kernel.state.activeKernel = this;
+  }
+  options;
+  static stateKey = /* @__PURE__ */ Symbol.for(
+    "@haskou/ddd-kernel/kernel-state"
+  );
+  consumerMiddlewares = [];
+  consumersList = [];
+  loggerInstance;
+  routesList = [];
+  schedulersList = [];
+  shutdownHooks = [];
+  dependencyInjectionInstance;
+  static get state() {
+    const stateContainer = globalThis;
+    stateContainer[_Kernel.stateKey] = stateContainer[_Kernel.stateKey] ?? {};
+    return stateContainer[_Kernel.stateKey];
+  }
+  static get configDirectory() {
+    return path2.resolve(_Kernel.rootDirectory, "config");
+  }
+  static get consumers() {
+    return _Kernel.getActiveKernel().consumers;
+  }
+  static get consumerMiddleware() {
+    return _Kernel.getActiveKernel().consumerMiddleware;
+  }
+  static get di() {
+    return _Kernel.getActiveKernel().di;
+  }
+  static get logger() {
+    return _Kernel.getActiveKernel().logger;
+  }
+  static get rootDirectory() {
+    return process.cwd();
+  }
+  static get routes() {
+    return _Kernel.getActiveKernel().routes;
+  }
+  static get schedulers() {
+    return _Kernel.getActiveKernel().schedulers;
+  }
+  static get sourceDirectory() {
+    return path2.resolve(_Kernel.rootDirectory, "src");
+  }
+  static getActiveKernel() {
+    if (!_Kernel.state.activeKernel) {
+      _Kernel.state.activeKernel = new _Kernel();
+    }
+    return _Kernel.state.activeKernel;
+  }
+  async closeCandidate(candidate) {
+    if (candidate.shutdown) {
+      await candidate.shutdown();
+      return;
+    }
+    if (candidate.close) {
+      await candidate.close();
+      return;
+    }
+    if (candidate.stop) {
+      await candidate.stop();
+      return;
+    }
+    if (candidate.flush) {
+      await candidate.flush();
+    }
+  }
+  getConsumerFromClass(ClassDefinition) {
+    return this.di.getService(ClassDefinition);
+  }
+  getInitializerFromClass(ClassDefinition) {
+    return this.di.getService(ClassDefinition);
+  }
+  getRuntimeFromClass(ClassDefinition) {
+    return this.di.getService(ClassDefinition);
+  }
+  getSchedulerFromClass(ClassDefinition) {
+    return this.di.getService(ClassDefinition);
+  }
+  get consumers() {
+    return this.consumersList;
+  }
+  get consumerMiddleware() {
+    return this.consumerMiddlewares;
+  }
+  get di() {
+    if (!this.dependencyInjectionInstance) {
+      throw new Error("Kernel dependency injection has not been initialized.");
+    }
+    return this.dependencyInjectionInstance;
+  }
+  get logger() {
+    return this.loggerInstance;
+  }
+  get routes() {
+    return this.routesList;
+  }
+  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
+    });
+    await this.dependencyInjectionInstance.compile();
+  }
+  getRoutes() {
+    return this.routes;
+  }
+  registerConsumerMiddleware(...middlewares) {
+    this.consumerMiddlewares.push(...middlewares);
+  }
+  registerConsumers(...ClassDefinitions) {
+    for (const ClassDefinition of ClassDefinitions) {
+      this.consumersList.push(this.getConsumerFromClass(ClassDefinition));
+    }
+  }
+  registerConsumerInstances(...consumers) {
+    this.consumersList.push(...consumers);
+  }
+  registerRoutes(...ClassDefinitions) {
+    this.routesList.push(...ClassDefinitions);
+  }
+  registerSchedulers(...ClassDefinitions) {
+    for (const ClassDefinition of ClassDefinitions) {
+      this.schedulersList.push(this.getSchedulerFromClass(ClassDefinition));
+    }
+  }
+  registerSchedulerInstances(...schedulers) {
+    this.schedulersList.push(...schedulers);
+  }
+  registerShutdownHook(hook) {
+    this.shutdownHooks.push(hook);
+  }
+  removeConsumers() {
+    this.consumersList.length = 0;
+  }
+  removeRoutes() {
+    this.routesList.length = 0;
+  }
+  removeSchedulers() {
+    this.schedulersList.length = 0;
+  }
+  async runConsumers() {
+    for (const consumer of this.consumersList) {
+      await consumer.init();
+    }
+  }
+  async runInitializers(...ClassDefinitions) {
+    for (const ClassDefinition of ClassDefinitions) {
+      await this.getInitializerFromClass(ClassDefinition).ensure();
+    }
+  }
+  async runRuntimes(...ClassDefinitions) {
+    for (const ClassDefinition of ClassDefinitions) {
+      const runtime = this.getRuntimeFromClass(ClassDefinition);
+      await runtime.run();
+      this.registerShutdownHook(
+        () => this.closeCandidate(runtime)
+      );
+    }
+  }
+  async runSchedulerNowAndSchedule(ClassDefinition) {
+    const scheduler = this.getSchedulerFromClass(ClassDefinition);
+    await scheduler.runOnce();
+    await scheduler.init();
+    this.schedulersList.push(scheduler);
+  }
+  async runSchedulers() {
+    for (const scheduler of this.schedulersList) {
+      await scheduler.init();
+    }
+  }
+  async shutdown() {
+    for (const consumer of [...this.consumersList].reverse()) {
+      await this.closeCandidate(consumer);
+    }
+    for (const scheduler of [...this.schedulersList].reverse()) {
+      await this.closeCandidate(scheduler);
+    }
+    for (const hook of [...this.shutdownHooks].reverse()) {
+      await hook();
+    }
+    await this.closeCandidate(this.loggerInstance);
+  }
+};
+
+// src/adapters/pubsub/amqp/InvalidDomainEventError.ts
+var InvalidDomainEventError = class extends Error {
+  constructor(message) {
+    super(`Invalid domain event: ${message}`);
+    this.name = "InvalidDomainEventError";
+  }
+};
+
+// src/adapters/pubsub/amqp/NoFailedMessagesError.ts
+var NoFailedMessagesError = class extends Error {
+  constructor(queueName) {
+    super(`No failed messages found in "${queueName}".`);
+    this.name = "NoFailedMessagesError";
+  }
+};
+
+// src/adapters/pubsub/amqp/AmqpMessageBusAdapter.ts
+var AmqpMessageBusAdapter = class {
+  constructor(options = {}) {
+    this.options = options;
+    this.exchange = options.exchange ?? options.serviceName ?? process.env.SERVICE_NAME ?? "";
+  }
+  options;
+  channelInstance;
+  connection;
+  delayConsumers = [];
+  exchange;
+  get dsn() {
+    return this.options.dsn ?? process.env.TRANSPORT_DSN ?? "";
+  }
+  get logger() {
+    return this.options.logger ?? Kernel.logger;
+  }
+  get maxRetries() {
+    const configuredRetries = this.options.maxRetries ?? process.env.TRANSPORT_MAX_RETRIES;
+    if (configuredRetries === void 0) {
+      return void 0;
+    }
+    return Number(configuredRetries);
+  }
+  get retryDelayInMilliseconds() {
+    const retryDelayFromEnv = Number(process.env.TRANSPORT_RETRY_DELAY);
+    return this.options.retryDelayInMilliseconds ?? (Number.isFinite(retryDelayFromEnv) ? retryDelayFromEnv : 1e3);
+  }
+  instanceDomainEvent(DomainEventInstance, message) {
+    if (!message) {
+      throw new InvalidDomainEventError(JSON.stringify(message));
+    }
+    return new DomainEventInstance(
+      message.aggregate_id,
+      message.attributes,
+      message.event_id,
+      message.occurred_on ? new Date(message.occurred_on) : /* @__PURE__ */ new Date(),
+      message.correlation_id,
+      message.causation_id
+    );
+  }
+  async handle(msg, context) {
+    const message = JSON.parse(msg.content.toString());
+    this.logger?.info(
+      `AMQP message bus (${context.queueName}) handling message: ${JSON.stringify(message)}`
+    );
+    try {
+      const domainEvent = this.instanceDomainEvent(
+        context.DomainEventInstance,
+        message
+      );
+      await context.handler(domainEvent);
+    } catch (error) {
+      await this.handleError(msg, message, context, error);
+    }
+  }
+  async handleError(msg, message, context, error) {
+    this.logger?.error(error instanceof Error ? error.message : String(error));
+    const headers = msg.properties.headers ?? {};
+    const retryCount = Number(headers.retries ?? 0);
+    if (this.maxRetries !== void 0 && retryCount <= this.maxRetries) {
+      await this.retry(message, headers, context);
+      return;
+    }
+    await this.sendToDlx(message, context, String(error));
+  }
+  async retry(message, headers, context) {
+    const retry = Number(headers.retries || 1);
+    const delayTimeInMs = retry * this.retryDelayInMilliseconds;
+    const delayedQueueName = `${context.queueName}_delayed_${delayTimeInMs}`;
+    const delayedRoutingKey = `${context.queueName}_${context.bindingKey}_delayed_${delayTimeInMs}`;
+    const consumerTag = `${delayedQueueName}_${randomUUID()}`;
+    this.logger?.info(`Retry # ${retry}`);
+    if (!this.delayConsumers.includes(delayedQueueName)) {
+      await this.registerDelayedConsumer(
+        delayedQueueName,
+        delayedRoutingKey,
+        delayTimeInMs,
+        consumerTag,
+        context
+      );
+    }
+    try {
+      const domainEvent = this.instanceDomainEvent(
+        context.DomainEventInstance,
+        message
+      );
+      context.channel.publish(
+        this.exchange,
+        delayedRoutingKey,
+        Buffer.from(JSON.stringify(message)),
+        this.opts(domainEvent, retry)
+      );
+    } catch (error) {
+      await context.channel.cancel(consumerTag);
+      this.logger?.error(
+        error instanceof Error ? error.message : String(error)
+      );
+    }
+  }
+  async registerDelayedConsumer(delayedQueueName, delayedRoutingKey, delayTimeInMs, consumerTag, context) {
+    await context.channel.assertExchange(this.exchange, "topic", {
+      durable: true
+    });
+    await context.channel.assertQueue(delayedQueueName, {
+      autoDelete: true,
+      deadLetterExchange: this.exchange,
+      deadLetterRoutingKey: delayedRoutingKey,
+      durable: false,
+      messageTtl: delayTimeInMs
+    });
+    await context.channel.bindQueue(
+      delayedQueueName,
+      this.exchange,
+      delayedRoutingKey
+    );
+    this.delayConsumers.push(delayedQueueName);
+    await context.channel.consume(
+      delayedQueueName,
+      async (msg) => {
+        if (!msg) {
+          return;
+        }
+        await new Promise((resolve) => setTimeout(resolve, delayTimeInMs));
+        await this.handle(msg, context);
+        this.removeDelayConsumer(delayedQueueName);
+        await context.channel.cancel(consumerTag);
+      },
+      { consumerTag, noAck: true }
+    );
+  }
+  removeDelayConsumer(delayedQueueName) {
+    const index = this.delayConsumers.indexOf(delayedQueueName);
+    if (index !== -1) {
+      this.delayConsumers.splice(index, 1);
+    }
+  }
+  async sendToDlx(message, context, error) {
+    await context.channel.assertExchange(this.exchange, "topic");
+    const dlxQueueName = `${context.queueName}_dlx`;
+    const dlxRoutingKey = `${context.queueName}_${context.bindingKey}_dlx`;
+    await context.channel.assertQueue(dlxQueueName, {
+      deadLetterExchange: this.exchange,
+      deadLetterRoutingKey: dlxRoutingKey,
+      durable: true
+    });
+    await context.channel.bindQueue(dlxQueueName, this.exchange, dlxRoutingKey);
+    try {
+      const domainEvent = this.instanceDomainEvent(
+        context.DomainEventInstance,
+        message
+      );
+      context.channel.publish(
+        this.exchange,
+        dlxRoutingKey,
+        Buffer.from(JSON.stringify(message)),
+        this.opts(domainEvent, message.retries, error)
+      );
+    } catch (publishError) {
+      this.logger?.error(
+        publishError instanceof Error ? publishError.message : String(publishError)
+      );
+    }
+  }
+  async connect() {
+    this.connection = await amqplib.connect(this.getConnectionDsn());
+    this.channelInstance = await this.connection.createChannel();
+    this.channelInstance.on("close", async () => {
+      this.logger?.error("AMQP message bus event close");
+      await this.reconnect();
+    }).on("error", async (error) => {
+      this.logger?.error(`AMQP message bus event error: ${error.message}`);
+      await this.reconnect();
+    });
+  }
+  async reconnect() {
+    await this.connect();
+    for (const consumer of Kernel.consumers) {
+      await consumer.init();
+    }
+  }
+  async channel(forceNew = false) {
+    if (forceNew) {
+      const connection = await amqplib.connect(this.getConnectionDsn());
+      return connection.createChannel();
+    }
+    if (!this.channelInstance) {
+      await this.connect();
+    }
+    if (!this.channelInstance) {
+      throw new Error("AMQP channel could not be created.");
+    }
+    await this.channelInstance.assertExchange(this.exchange, "topic", {
+      durable: true
+    });
+    return this.channelInstance;
+  }
+  getConnectionDsn() {
+    const separator = this.dsn.includes("?") ? "&" : "?";
+    return `${this.dsn}${separator}heartbeat=60`;
+  }
+  opts(event, retries, error) {
+    return {
+      appId: this.options.serviceName ?? process.env.SERVICE_NAME,
+      contentEncoding: "utf-8",
+      contentType: "application/json",
+      deliveryMode: 2,
+      headers: {
+        error,
+        retries: retries ? retries + 1 : 0
+      },
+      messageId: event.eventId,
+      priority: 0,
+      timestamp: event.occurredOn.getTime(),
+      type: event.eventName()
+    };
+  }
+  getMessagesToRetry(requestedMessagesToRetry, availableMessages) {
+    return requestedMessagesToRetry ?? availableMessages;
+  }
+  async retryDlxMessage(msg, DomainEventInstance, handler, channel) {
+    const content = msg.content.toString();
+    this.logger?.info(`Retrying message from DLX ${content}`);
+    try {
+      const message = JSON.parse(content);
+      const domainEvent = this.instanceDomainEvent(
+        DomainEventInstance,
+        message
+      );
+      await handler(domainEvent);
+      this.logger?.info(`${content} successfully handled.`);
+      channel.ack(msg);
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      this.logger?.error(`${content} error with ${errorMessage}.`);
+      channel.nack(msg);
+    }
+  }
+  async areQueuesBound() {
+    if (Kernel.consumers.length === 0) {
+      return false;
+    }
+    const channel = await this.channel();
+    for (const consumer of Kernel.consumers) {
+      const queueChecker = await channel.checkQueue(consumer.queueName);
+      if (queueChecker.consumerCount !== 0) {
+        return false;
+      }
+    }
+    return true;
+  }
+  async consumeDlx(queueName, DomainEventInstance, handler, messagesToRetry) {
+    const dlxQueueName = `${queueName}_dlx`;
+    const channel = await this.channel(true);
+    channel.on("error", () => {
+      this.logger?.error("AMQP message bus event error");
+    });
+    const queue = await channel.checkQueue(dlxQueueName);
+    const messagesToRetryCount = this.getMessagesToRetry(
+      messagesToRetry,
+      queue.messageCount
+    );
+    this.logger?.info(
+      `Retrying ${messagesToRetryCount} messages from DLX ${dlxQueueName}`
+    );
+    if (messagesToRetryCount > 0 && queue.messageCount !== 0) {
+      for (let index = 0; index < messagesToRetryCount; index++) {
+        const msg = await channel.get(dlxQueueName);
+        if (msg === false) {
+          continue;
+        }
+        await this.retryDlxMessage(msg, DomainEventInstance, handler, channel);
+      }
+      return;
+    }
+    throw new NoFailedMessagesError(dlxQueueName);
+  }
+  async consume(queueName, bindingKey, DomainEventInstance, exchange, handler) {
+    const channel = await this.channel();
+    await channel.assertQueue(queueName, { durable: true });
+    await channel.assertExchange(exchange, "topic");
+    await channel.prefetch(1);
+    await channel.bindQueue(queueName, exchange, bindingKey);
+    const context = {
+      bindingKey,
+      channel,
+      DomainEventInstance,
+      handler,
+      queueName
+    };
+    await channel.consume(queueName, async (msg) => {
+      if (!msg) {
+        return;
+      }
+      await this.handle(msg, context);
+      channel.ack(msg);
+    });
+  }
+  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)
+      );
+    }
+  }
+  async close() {
+    await this.channelInstance?.close();
+    await this.connection?.close();
+    this.channelInstance = void 0;
+    this.connection = void 0;
+  }
+};
+export {
+  InvalidDomainEventError,
+  NoFailedMessagesError,
+  AmqpMessageBusAdapter as default
+};
+//# sourceMappingURL=index.js.map