wsp-ms-core 1.1.24 → 1.1.26

package/dist/index.cjs

@@ -1781,10 +1781,22 @@ var KafkaManager = class extends EventManager {
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     this.runtimeProcess = globalThis?.process;
     this.producerConnected = false;
-    this.exitingDueToLeaderError = false;
-    this.brokers = this.resolveBrokerList(this._connection.brokers ?? []);
+    this.isRecoveringLeader = false;
+    this.seedBrokers = this.resolveBrokerList(this._connection.brokers ?? []);
+    this.groupId = this.runtimeProcess?.env?.KAFKA_GROUP || "default";
+    this.initializeKafkaClients(this.seedBrokers);
+    this.leaderSelectionPromise = this.pinToLeaderBroker();
+  }
+  async ensureProducerConnected() {
+    await this.waitForLeaderSelection();
+    if (this.producerConnected)
+      return;
+    await this.producer.connect();
+    this.producerConnected = true;
+  }
+  initializeKafkaClients(brokers) {
     this.kafka = new import_kafkajs.Kafka({
-      brokers: this.brokers,
+      brokers,
       ssl: true,
       sasl: {
         mechanism: "scram-sha-256",
@@ -1793,16 +1805,92 @@ var KafkaManager = class extends EventManager {
       },
       logLevel: import_kafkajs.logLevel.ERROR
     });
-    const groupId = this.runtimeProcess?.env?.KAFKA_GROUP || "default";
-    this.consumer = this.kafka.consumer({ groupId });
+    this.consumer = this.kafka.consumer({ groupId: this.groupId });
     this.producer = this.kafka.producer();
+    this.brokers = brokers;
+    this.producerConnected = false;
     this.registerConsumerEventHandlers();
   }
-  async ensureProducerConnected() {
-    if (this.producerConnected)
+  async pinToLeaderBroker() {
+    try {
+      const leaderBroker = await this.fetchLeaderBroker(this.kafka);
+      if (!leaderBroker) {
+        console.warn("[KafkaManager] Unable to determine leader broker. Using configured list.", { brokers: this.brokers });
+        return;
+      }
+      if (this.brokers.length === 1 && this.brokers[0] === leaderBroker) {
+        return;
+      }
+      console.info("[KafkaManager] Leader broker resolved. Reinitializing clients", { leaderBroker });
+      this.initializeKafkaClients([leaderBroker]);
+    } catch (error) {
+      console.warn("[KafkaManager] Error resolving leader broker. Falling back to configured brokers.", error);
+    }
+  }
+  buildKafkaClient(brokers) {
+    return new import_kafkajs.Kafka({
+      brokers,
+      ssl: true,
+      sasl: {
+        mechanism: "scram-sha-256",
+        username: this._connection.userName,
+        password: this._connection.password
+      },
+      logLevel: import_kafkajs.logLevel.ERROR
+    });
+  }
+  async fetchLeaderBroker(kafkaClient) {
+    const admin = kafkaClient.admin();
+    try {
+      await admin.connect();
+      const cluster = await admin.describeCluster();
+      const controllerId = cluster?.controller;
+      const controller = controllerId !== void 0 ? cluster?.brokers?.find((node) => node.nodeId === controllerId) : void 0;
+      if (!controller?.host) {
+        return null;
+      }
+      const host = controller.host;
+      const port = controller.port ?? 9092;
+      return this.normalizeBroker(`${host}:${port}`);
+    } finally {
+      await admin.disconnect().catch(() => void 0);
+    }
+  }
+  async recoverFromLeaderChange(origin) {
+    if (this.isRecoveringLeader)
       return;
-    await this.producer.connect();
-    this.producerConnected = true;
+    this.isRecoveringLeader = true;
+    console.warn("[KafkaManager] Recovering from leader change", { origin, brokers: this.brokers });
+    await this.execCallback(this._onReconnect, {
+      message: "[KafkaManager] Leader change detected. Reconnecting to new leader.",
+      context: { origin }
+    });
+    try {
+      await this.stop().catch((error) => {
+        console.warn("[KafkaManager] Error stopping previous connection during recovery", error);
+      });
+      const seedClient = this.buildKafkaClient(this.seedBrokers);
+      const leaderBroker = await this.fetchLeaderBroker(seedClient).catch((error) => {
+        console.warn("[KafkaManager] Error resolving new leader broker during recovery", error);
+        return null;
+      });
+      const brokersToUse = leaderBroker ? [leaderBroker] : this.seedBrokers;
+      console.info("[KafkaManager] Reconnecting using brokers", { brokersToUse });
+      this.initializeKafkaClients(brokersToUse);
+      this.leaderSelectionPromise = Promise.resolve();
+      await this.run();
+    } catch (error) {
+      console.error("[KafkaManager] Failed to recover from leader change", { origin, error });
+      await this.execCallback(this._onError, error);
+    } finally {
+      this.isRecoveringLeader = false;
+    }
+  }
+  async waitForLeaderSelection() {
+    try {
+      await this.leaderSelectionPromise;
+    } catch {
+    }
   }
   resolveBrokerList(brokers) {
     const envBrokers = (this.runtimeProcess?.env?.KAFKA_BROKERS ?? "").split(",").map((value) => value.trim()).filter(Boolean);
@@ -1843,6 +1931,9 @@ var KafkaManager = class extends EventManager {
     this.consumer.on(events.CRASH, async (event) => {
       await this.logConsumerEvent("CRASH", event, "error");
       this.handleKafkaError(event?.payload?.error, "consumer.CRASH", { broker: event?.payload?.broker });
+      if (event?.payload?.restart === false) {
+        void this.recoverFromLeaderChange("consumer.CRASH.no-restart");
+      }
     });
     this.consumer.on(events.DISCONNECT, async (event) => {
       await this.logConsumerEvent("DISCONNECT", event, "error");
@@ -1884,8 +1975,7 @@ var KafkaManager = class extends EventManager {
       return;
     const errorType = error.type ?? error.name;
     const isNotLeaderError = errorType === "NOT_LEADER_FOR_PARTITION" || error?.name === "KafkaJSNotLeaderForPartition";
-    if (!this.exitingDueToLeaderError && isNotLeaderError) {
-      this.exitingDueToLeaderError = true;
+    if (isNotLeaderError) {
       const payload = {
         origin,
         broker: error?.broker ?? metadata?.broker,
@@ -1893,12 +1983,12 @@ var KafkaManager = class extends EventManager {
         partition: error?.partition,
         metadata
       };
-      console.error("[KafkaManager][NOT_LEADER_FOR_PARTITION] Forcing shutdown", payload);
+      console.error("[KafkaManager][NOT_LEADER_FOR_PARTITION] Reconnecting to new leader", payload);
       void this.execCallback(this._onCrash, {
-        message: "[KafkaManager] NOT_LEADER_FOR_PARTITION detected. Forcing shutdown.",
+        message: "[KafkaManager] NOT_LEADER_FOR_PARTITION detected. Reconnecting to new leader.",
         context: payload
       });
-      setTimeout(() => this.runtimeProcess?.exit?.(1), 0);
+      void this.recoverFromLeaderChange(origin);
       return;
     }
     if (error instanceof import_kafkajs.KafkaJSRequestTimeoutError || errorType === "REQUEST_TIMEOUT") {
@@ -1911,6 +2001,7 @@ var KafkaManager = class extends EventManager {
   }
   async run(autocommit = false) {
     const __run = async () => {
+      await this.waitForLeaderSelection();
       await this.execCallback(this._onStart, { message: `--- ${this.constructor.name} started ---` });
       await this.consumer.connect();
       await this.execCallback(this._onConnected, { message: `--- ${this.constructor.name} connected to ${this.brokers.join(", ")} ---` });
@@ -1963,6 +2054,7 @@ var KafkaManager = class extends EventManager {
     }
   }
   async send(e) {
+    await this.waitForLeaderSelection();
     const evt = {
       date: DateTime.now().value,
       tenant: e.tenant.value,