wsp-ms-core 1.1.29 → 1.1.30

package/dist/index.cjs

@@ -1803,18 +1803,44 @@ var KafkaManager = class extends EventManager {
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     this.runtimeProcess = globalThis?.process;
     this.producerConnected = false;
+    this.producerConnectPromise = null;
     this.isRecoveringLeader = false;
     this.seedBrokers = this.resolveBrokerList(this._connection.brokers ?? []);
-    this.groupId = this.runtimeProcess?.env?.KAFKA_GROUP || "default";
+    const envGroupId = this.runtimeProcess?.env?.KAFKA_GROUP;
+    this.hasExplicitGroupId = Boolean(envGroupId);
+    this.groupId = envGroupId || "__missing-kafka-group__";
+    if (!this.hasExplicitGroupId) {
+      console.warn("[KafkaManager] KAFKA_GROUP is not set. Producing is allowed, but consuming will fail until a unique group id is configured.");
+    }
     this.initializeKafkaClients(this.seedBrokers);
     this.leaderSelectionPromise = this.pinToLeaderBroker();
   }
+  // La conexión se comparte entre sends concurrentes vía un latch: sin él, dos send() en paralelo
+  // dispararían dos connect() simultáneos sobre el mismo producer. El producer queda conectado
+  // entre sends (kafkajs está diseñado para conexiones long-lived); solo stop() lo desconecta.
+  // Los guards `this.producer === producer` protegen contra initializeKafkaClients() reemplazando
+  // el producer a mitad de un connect (recovery de líder): sin ellos, el latch viejo marcaría como
+  // conectado al producer nuevo sin estarlo, y todos los sends siguientes fallarían.
   async ensureProducerConnected() {
     await this.waitForLeaderSelection();
     if (this.producerConnected)
       return;
-    await this.producer.connect();
-    this.producerConnected = true;
+    if (!this.producerConnectPromise) {
+      const producer = this.producer;
+      this.producerConnectPromise = producer.connect().then(() => {
+        if (this.producer === producer) {
+          this.producerConnected = true;
+        }
+      }).finally(() => {
+        if (this.producer === producer) {
+          this.producerConnectPromise = null;
+        }
+      });
+    }
+    await this.producerConnectPromise;
+    if (!this.producerConnected) {
+      return this.ensureProducerConnected();
+    }
   }
   initializeKafkaClients(brokers) {
     this.kafka = new import_kafkajs.Kafka({
@@ -1831,6 +1857,7 @@ var KafkaManager = class extends EventManager {
     this.producer = this.kafka.producer();
     this.brokers = brokers;
     this.producerConnected = false;
+    this.producerConnectPromise = null;
     this.registerConsumerEventHandlers();
   }
   async pinToLeaderBroker() {
@@ -2021,7 +2048,22 @@ var KafkaManager = class extends EventManager {
     const next = (BigInt(message.offset) + 1n).toString();
     await this.consumer.commitOffsets([{ topic, partition, offset: next }]);
   }
+  // Mantiene viva la sesión del consumer mientras un handler tarda más que el sessionTimeout
+  // (default 30s de kafkajs). Sin esto, un handler lento hace que el broker expulse al consumer
+  // a mitad de procesamiento → rebalance → el mensaje se reentrega → loop. kafkajs ya throttlea
+  // heartbeat() internamente al heartbeatInterval, así que llamarlo de más no tiene costo.
+  startHeartbeatLoop(heartbeat) {
+    const interval = setInterval(() => {
+      heartbeat().catch((error) => {
+        console.warn("[KafkaManager] Heartbeat failed during message processing", { error: error?.message ?? error });
+      });
+    }, 5e3);
+    return () => clearInterval(interval);
+  }
   async run(autocommit = false) {
+    if (!this.hasExplicitGroupId) {
+      throw new InternalError(ErrorManager.APP_ERRORS.PROCESS, "KAFKA_GROUP env var is required to consume. Set a unique consumer group id per service.");
+    }
     const __run = async () => {
       await this.waitForLeaderSelection();
       await this.execCallback(this._onStart, { message: `--- ${this.constructor.name} started ---` });
@@ -2069,7 +2111,12 @@ var KafkaManager = class extends EventManager {
             console.log("[KafkaManager] H - before execRoute", {
               offset: message.offset
             });
-            await this.execRoute(topic, event);
+            const stopHeartbeatLoop = this.startHeartbeatLoop(heartbeat);
+            try {
+              await this.execRoute(topic, event);
+            } finally {
+              stopHeartbeatLoop();
+            }
             console.log("[KafkaManager] I - after execRoute", {
               elapsedMs: Date.now() - execRouteStart
             });
@@ -2137,8 +2184,6 @@ var KafkaManager = class extends EventManager {
           }
         ]
       });
-      await this.producer.disconnect();
-      this.producerConnected = false;
     } catch (error) {
       throw new InternalError(error.toString());
     }
@@ -2155,6 +2200,9 @@ var KafkaManager = class extends EventManager {
   async stop() {
     await this.consumer.stop();
     await this.consumer.disconnect();
+    if (this.producerConnectPromise) {
+      await this.producerConnectPromise.catch(() => void 0);
+    }
     if (this.producerConnected) {
       await this.producer.disconnect();
       this.producerConnected = false;
@@ -2366,6 +2414,7 @@ var DefaultMysqlInboxRunner = class {
   }
   async saveEvent(e, repository) {
     try {
+      console.log("[InboxRunner] BEFORE create inbox record");
       let record = new InboxRecord(
         UUID.create(),
         e.tenant,
@@ -2374,7 +2423,9 @@ var DefaultMysqlInboxRunner = class {
         JSON.stringify(e.message),
         ProcessStatus.PENDING
       );
+      console.log("[InboxRunner] BEFORE repository.create");
       await repository.create(record);
+      console.log("[InboxRunner] AFTER repository.create");
     } catch (error) {
       throw error;
     }