@orion-js/echoes 4.4.0 → 4.4.1

package/dist/index.cjs

@@ -43,20 +43,25 @@ __export(index_exports, {
 });
 module.exports = __toCommonJS(index_exports);
 
+// src/startService/index.ts
+var import_http2 = require("@orion-js/http");
+
 // src/config.ts
 var config = {};
 var config_default = config;
 
-// src/requestsHandler/getEcho.ts
-function getEcho_default(method) {
-  const echo2 = config_default.echoes[method];
-  if (!echo2) {
-    throw new Error(`Echo named ${method} not found in this service`);
-  }
-  if (echo2.type !== "request") {
-    throw new Error(`Echo named ${method} is not of type request`);
+// src/startService/KafkaManager.ts
+var import_node_crypto = require("crypto");
+var import_logger = require("@orion-js/logger");
+var import_kafkajs = require("kafkajs");
+
+// src/echo/deserialize.ts
+function deserialize_default(serializedJavascript) {
+  try {
+    return eval("(" + serializedJavascript + ")");
+  } catch (error) {
+    throw new Error("Error deserializing echo message");
   }
-  return echo2;
 }
 
 // src/publish/serialize.ts
@@ -68,107 +73,90 @@ function serialize_default(data) {
   return serialized;
 }
 
-// src/request/getSignature.ts
-var import_jssha = __toESM(require("jssha"), 1);
-
-// src/request/getPassword.ts
-var import_logger = require("@orion-js/logger");
-var import_env = require("@orion-js/env");
-function getEchoesPassword() {
-  var _a, _b;
-  const secret = ((_b = (_a = config_default) == null ? void 0 : _a.requests) == null ? void 0 : _b.key) || (0, import_env.internalGetEnv)("echoes_password", "ECHOES_PASSWORD");
-  if (!secret) {
-    import_logger.logger.warn(
-      'Warning: no secret key found for echoes requests. Init echoes or set the env var "echoes_password" or process.env.ECHOES_PASSWORD'
-    );
-  }
-  return secret;
-}
-
-// src/request/getSignature.ts
-function getSignature_default(body) {
-  const password = getEchoesPassword();
-  const shaObj = new import_jssha.default("SHA-1", "TEXT");
-  shaObj.setHMACKey(password, "TEXT");
-  shaObj.update(body);
-  return shaObj.getHMAC("HEX");
-}
-
-// src/requestsHandler/checkSignature.ts
-function checkSignature_default(body, signature) {
-  const generatedSignature = getSignature_default(body);
-  if (generatedSignature !== signature) {
-    throw new Error("Echoes invalid signature");
-  }
-}
-
-// src/requestsHandler/index.ts
-var import_http = require("@orion-js/http");
-var requestsHandler_default = (options) => (0, import_http.route)({
-  method: "post",
-  path: options.requests.handlerPath || "/echoes-services",
-  bodyParser: "json",
-  bodyParserOptions: {
-    limit: "10mb"
-  },
-  async resolve(req) {
-    try {
-      const { body, signature } = req.body;
-      checkSignature_default(body, signature);
-      const { method, serializedParams } = body;
-      const echo2 = getEcho_default(method);
-      const result = await echo2.onRequest(serializedParams);
-      return {
-        body: {
-          result: serialize_default(result)
-        }
-      };
-    } catch (error) {
-      if (!error.getInfo) {
-        console.error("Error at echo requests handler:", error);
-      }
-      return {
-        body: {
-          error: error.message,
-          errorInfo: error.getInfo ? error.getInfo() : null,
-          isValidationError: !!error.isValidationError,
-          isUserError: !!error.isUserError
-        }
-      };
-    }
-  }
-});
-
 // src/startService/KafkaManager.ts
-var import_kafkajs = require("kafkajs");
-var import_logger2 = require("@orion-js/logger");
 var HEARTBEAT_INTERVAL_SECONDS = 5;
 var CHECK_JOIN_CONSUMER_INTERVAL_SECONDS = 30;
 var DEFAULT_PARTITIONS_CONSUMED_CONCURRENTLY = 4;
 var DEFAULT_MEMBERS_TO_PARTITIONS_RATIO = 1;
 var KafkaManager = class {
+  name = "kafka";
   kafka;
   options;
   producer;
   consumer;
-  topics;
-  started;
+  topics = [];
+  subscriptions = /* @__PURE__ */ new Map();
+  onEvent;
+  consumerStarted = false;
+  producerConnected = false;
   interval;
   constructor(options) {
     this.kafka = new import_kafkajs.Kafka(options.client);
     this.options = options;
-    this.producer = this.kafka.producer(options.producer);
-    this.consumer = this.kafka.consumer(options.consumer);
-    this.topics = Object.keys(options.echoes).filter((key) => options.echoes[key].type === "event");
+  }
+  async start(options) {
+    var _a;
+    this.onEvent = options.onEvent;
+    this.subscriptions = new Map(
+      options.subscriptions.map((subscription) => [subscription.topic, subscription])
+    );
+    this.topics = options.subscriptions.map((subscription) => subscription.topic);
+    if (options.publish || options.consume) {
+      this.producer = this.kafka.producer(this.options.producer);
+      await this.producer.connect();
+      this.producerConnected = true;
+    }
+    if (!options.consume || this.topics.length === 0) return;
+    if (!((_a = this.options.consumer) == null ? void 0 : _a.groupId)) {
+      throw new Error("Echoes Kafka consumers require consumer.groupId");
+    }
+    this.consumer = this.kafka.consumer(this.options.consumer);
+    this.consumerStarted = await this.conditionalStart();
+    if (this.consumerStarted) return;
+    import_logger.logger.info("Echoes: Delaying consumer group join, waiting for conditions to be met");
+    this.interval = setInterval(async () => {
+      this.consumerStarted = await this.conditionalStart();
+      if (this.consumerStarted) clearInterval(this.interval);
+    }, CHECK_JOIN_CONSUMER_INTERVAL_SECONDS * 1e3);
+  }
+  async publish(options) {
+    if (!this.producer || !this.producerConnected) {
+      throw new Error("Echoes Kafka producer is not connected");
+    }
+    return await this.producer.send({
+      acks: options.acks,
+      timeout: options.timeout,
+      topic: options.topic,
+      messages: [
+        {
+          value: serialize_default({ params: options.params }),
+          headers: {
+            "echoes-event-id": (0, import_node_crypto.randomUUID)()
+          }
+        }
+      ]
+    });
+  }
+  async close() {
+    var _a, _b;
+    import_logger.logger.warn("Echoes: Stopping Kafka transport");
+    if (this.interval) clearInterval(this.interval);
+    await Promise.all([
+      (_a = this.consumer) == null ? void 0 : _a.disconnect(),
+      this.producerConnected ? (_b = this.producer) == null ? void 0 : _b.disconnect() : void 0
+    ]);
+    this.consumerStarted = false;
+    this.producerConnected = false;
   }
   async checkJoinConsumerGroupConditions() {
     const admin = this.kafka.admin();
     try {
       await admin.connect();
-      const groupDescriptions = await admin.describeGroups([this.options.consumer.groupId]);
+      const groupId = this.options.consumer.groupId;
+      const groupDescriptions = await admin.describeGroups([groupId]);
       const group = groupDescriptions.groups[0];
       if (group.state === "Empty") {
-        import_logger2.logger.info(`Echoes: Consumer group ${this.options.consumer.groupId} is empty, joining`);
+        import_logger.logger.info(`Echoes: Consumer group ${groupId} is empty, joining`);
         return true;
       }
       const topicsMetadata = await admin.fetchTopicMetadata({ topics: this.topics });
@@ -176,23 +164,24 @@ var KafkaManager = class {
         (acc, topic) => acc + topic.partitions.length,
         0
       );
-      import_logger2.logger.info(
-        `Echoes: Consumer group ${this.options.consumer.groupId} has ${group.members.length} members and ${totalPartitions} partitions`
+      import_logger.logger.info(
+        `Echoes: Consumer group ${groupId} has ${group.members.length} members and ${totalPartitions} partitions`
       );
       const partitionsRatio = this.options.membersToPartitionsRatio || DEFAULT_MEMBERS_TO_PARTITIONS_RATIO;
       const partitionsThreshold = Math.ceil(totalPartitions * partitionsRatio);
       if (partitionsThreshold > group.members.length) {
-        import_logger2.logger.info(
-          `Echoes: Consumer group ${this.options.consumer.groupId} has room for more members ${group.members.length}/${partitionsThreshold}, joining`
+        import_logger.logger.info(
+          `Echoes: Consumer group ${groupId} has room for more members ${group.members.length}/${partitionsThreshold}, joining`
         );
         return true;
       }
+      return false;
     } catch (error) {
-      import_logger2.logger.error("Echoes: Error checking consumer group conditions, join", { error });
+      import_logger.logger.error("Echoes: Error checking consumer group conditions, join", { error });
       return true;
     } finally {
       await admin.disconnect().catch((error) => {
-        import_logger2.logger.error("Echoes: Error disconnecting admin client", { error });
+        import_logger.logger.error("Echoes: Error disconnecting admin client", { error });
       });
     }
   }
@@ -209,59 +198,68 @@ var KafkaManager = class {
       await this.joinConsumerGroup();
       return true;
     }
-  }
-  async start() {
-    if (this.started) return;
-    await this.producer.connect();
-    this.started = await this.conditionalStart();
-    if (this.started) return;
-    import_logger2.logger.info("Echoes: Delaying consumer group join, waiting for conditions to be met");
-    this.interval = setInterval(async () => {
-      this.started = await this.conditionalStart();
-      if (this.started) clearInterval(this.interval);
-    }, CHECK_JOIN_CONSUMER_INTERVAL_SECONDS * 1e3);
-  }
-  async stop() {
-    import_logger2.logger.warn("Echoes: Stopping echoes");
-    if (this.interval) clearInterval(this.interval);
-    if (this.consumer) await this.consumer.disconnect();
-    if (this.producer) await this.producer.disconnect();
+    return false;
   }
   async handleMessage(params) {
-    const echo2 = this.options.echoes[params.topic];
-    if (!echo2 || echo2.type !== "event") {
-      import_logger2.logger.warn(`Echoes: Received a message for an unknown topic: ${params.topic}, ignoring it`);
+    const subscription = this.subscriptions.get(params.topic);
+    if (!subscription) {
+      import_logger.logger.warn(`Echoes: Received a message for an unknown topic: ${params.topic}, ignoring it`);
       return;
     }
     let intervalsCount = 0;
     const heartbeatInterval = setInterval(async () => {
       await params.heartbeat().catch((error) => {
-        import_logger2.logger.warn(`Echoes: Error sending heartbeat: ${error.message}`);
+        import_logger.logger.warn(`Echoes: Error sending heartbeat: ${error.message}`);
       });
       intervalsCount++;
       if (intervalsCount * HEARTBEAT_INTERVAL_SECONDS % 30 === 0) {
-        import_logger2.logger.warn(
+        import_logger.logger.warn(
           `Echoes: Event is taking too long to process: ${params.topic} ${intervalsCount * HEARTBEAT_INTERVAL_SECONDS}s`
         );
       }
     }, HEARTBEAT_INTERVAL_SECONDS * 1e3);
     try {
-      await echo2.onMessage(params).catch((error) => this.handleRetries(echo2, params, error));
+      const event = this.createReceivedEvent(params);
+      await this.onEvent(event);
     } catch (error) {
-      import_logger2.logger.error("Echoes: error processing a message", { error, topic: params.topic });
-      throw error;
+      try {
+        await this.handleRetries(subscription, params, error);
+      } catch (retryError) {
+        import_logger.logger.error("Echoes: error processing a message", {
+          error: retryError,
+          topic: params.topic
+        });
+        throw retryError;
+      }
     } finally {
       clearInterval(heartbeatInterval);
     }
   }
-  async handleRetries(echo2, params, error) {
+  createReceivedEvent(params) {
+    var _a, _b, _c, _d;
+    const { message, topic, partition } = params;
+    const data = deserialize_default(message.value.toString());
+    const retries = Number.parseInt(((_b = (_a = message.headers) == null ? void 0 : _a.retries) == null ? void 0 : _b.toString()) || "0", 10);
+    const timestamp = Number.parseInt(message.timestamp || "", 10);
+    return {
+      id: ((_d = (_c = message.headers) == null ? void 0 : _c["echoes-event-id"]) == null ? void 0 : _d.toString()) || `kafka:${topic}:${partition}:${message.offset}`,
+      topic,
+      data,
+      transport: "kafka",
+      headers: message.headers,
+      createdAt: Number.isFinite(timestamp) ? new Date(timestamp) : /* @__PURE__ */ new Date(),
+      attempt: retries + 1,
+      context: params
+    };
+  }
+  async handleRetries(subscription, params, error) {
     var _a, _b;
     const { message, topic } = params;
     const retries = Number.parseInt(((_b = (_a = message == null ? void 0 : message.headers) == null ? void 0 : _a.retries) == null ? void 0 : _b.toString()) || "0", 10);
-    if (echo2.attemptsBeforeDeadLetter === void 0 || echo2.attemptsBeforeDeadLetter === null) {
+    if (subscription.attemptsBeforeDeadLetter === void 0 || subscription.attemptsBeforeDeadLetter === null) {
       throw error;
     }
-    const maxRetries = echo2.attemptsBeforeDeadLetter || 0;
+    const maxRetries = subscription.attemptsBeforeDeadLetter || 0;
     const exceededMaxRetries = retries >= maxRetries;
     const nextTopic = exceededMaxRetries ? `DLQ-${topic}` : topic;
     await this.producer.send({
@@ -270,6 +268,7 @@ var KafkaManager = class {
         {
           value: message.value.toString(),
           headers: {
+            ...message.headers,
             retries: String(retries + 1),
             error: error.message
           }
@@ -277,59 +276,322 @@ var KafkaManager = class {
       ]
     });
     if (exceededMaxRetries) {
-      import_logger2.logger.error(
+      import_logger.logger.error(
         "Echoes: a message has reached the maximum number of retries, sending it to DLQ",
         { topic: nextTopic }
       );
     } else {
-      import_logger2.logger.warn("Echoes: a retryable message failed", { error, topic: nextTopic });
+      import_logger.logger.warn("Echoes: a retryable message failed", { error, topic: nextTopic });
     }
   }
 };
 var KafkaManager_default = KafkaManager;
 
+// src/events/EventBus.ts
+var import_logger2 = require("@orion-js/logger");
+var EventBus = class {
+  echoes;
+  transports;
+  consumeFrom;
+  publishTo;
+  startedTransports = [];
+  started = false;
+  closed = false;
+  constructor(options) {
+    this.echoes = options.echoes;
+    this.transports = options.transports;
+    this.consumeFrom = [...new Set(options.consumeFrom)];
+    this.publishTo = options.publishTo;
+  }
+  async start() {
+    if (this.started) return;
+    const selected = new Set(this.consumeFrom);
+    if (this.publishTo) selected.add(this.publishTo);
+    for (const name of selected) {
+      if (!this.transports[name]) {
+        throw new Error(`Echoes event transport "${name}" is selected but not configured`);
+      }
+    }
+    const subscriptions = Object.entries(this.echoes).filter(([, echo2]) => echo2.type === "event").map(([topic, echo2]) => ({
+      topic,
+      attemptsBeforeDeadLetter: echo2.attemptsBeforeDeadLetter
+    }));
+    try {
+      for (const name of selected) {
+        const transport = this.transports[name];
+        this.startedTransports.push(transport);
+        await transport.start({
+          consume: this.consumeFrom.includes(name),
+          publish: this.publishTo === name,
+          subscriptions,
+          onEvent: (event) => this.handleEvent(event)
+        });
+      }
+      this.started = true;
+    } catch (error) {
+      await this.close().catch(() => void 0);
+      throw error;
+    }
+  }
+  async publish(options) {
+    if (!this.started) {
+      throw new Error("You must initialize echoes configuration to use publish");
+    }
+    if (!this.publishTo) {
+      throw new Error("Echoes does not have a publish transport configured");
+    }
+    return await this.transports[this.publishTo].publish(options);
+  }
+  async close() {
+    if (this.closed) return;
+    this.closed = true;
+    await Promise.all(this.startedTransports.map((transport) => transport.close()));
+  }
+  async handleEvent(event) {
+    const echo2 = this.echoes[event.topic];
+    if (!echo2 || echo2.type !== "event") {
+      import_logger2.logger.warn(`Echoes: Received a message for an unknown topic: ${event.topic}, ignoring it`);
+      return;
+    }
+    if (event.transport === "kafka" && event.context) {
+      await echo2.onMessage(event.context);
+      return;
+    }
+    if (echo2.onEvent) {
+      await echo2.onEvent(event);
+      return;
+    }
+    await echo2.resolve(event.data.params, {
+      ...event.context || {},
+      transport: event.transport,
+      eventId: event.id,
+      topic: event.topic,
+      headers: event.headers,
+      createdAt: event.createdAt,
+      attempt: event.attempt,
+      data: event.data
+    });
+  }
+};
+
+// src/events/PulseManager.ts
+var PulseManager = class {
+  name = "pulse";
+  options;
+  pulse;
+  subscriptions = [];
+  constructor(options) {
+    this.options = options;
+  }
+  async start(options) {
+    let pulseModule;
+    try {
+      pulseModule = await import("@orion-js/pulse");
+    } catch (error) {
+      const wrapped = new Error(
+        "Echoes Pulse transport requires @orion-js/pulse to be installed in the application"
+      );
+      wrapped.cause = error;
+      throw wrapped;
+    }
+    const { subscription, ...connectOptions } = this.options;
+    this.pulse = pulseModule.connect(connectOptions);
+    await this.pulse.awaitConnection();
+    if (!options.consume) return;
+    this.subscriptions = await Promise.all(
+      options.subscriptions.map(
+        (definition) => this.pulse.subscribe(
+          definition.topic,
+          (event) => options.onEvent(this.createReceivedEvent(event)),
+          this.getSubscribeOptions(subscription, definition.attemptsBeforeDeadLetter)
+        )
+      )
+    );
+  }
+  async publish(options) {
+    if (!this.pulse) {
+      throw new Error("Echoes Pulse client is not connected");
+    }
+    return await this.pulse.publish({
+      topic: options.topic,
+      data: { params: options.params }
+    });
+  }
+  async close() {
+    var _a;
+    await ((_a = this.pulse) == null ? void 0 : _a.close());
+    this.subscriptions = [];
+  }
+  getSubscribeOptions(defaults = {}, attemptsBeforeDeadLetter) {
+    return {
+      ...defaults,
+      ...attemptsBeforeDeadLetter === void 0 ? {} : { maxRetries: attemptsBeforeDeadLetter }
+    };
+  }
+  createReceivedEvent(event) {
+    return {
+      id: event.id,
+      topic: event.topic,
+      data: event.data,
+      transport: "pulse",
+      headers: event.headers,
+      createdAt: event.createdAt,
+      attempt: event.attempt,
+      context: event
+    };
+  }
+};
+
+// src/events/createEventBus.ts
+function resolveEventsConfig(options) {
+  var _a, _b, _c, _d;
+  const legacyKafka = options.client ? {
+    client: options.client,
+    producer: options.producer,
+    consumer: options.consumer,
+    readTopicsFromBeginning: options.readTopicsFromBeginning,
+    partitionsConsumedConcurrently: options.partitionsConsumedConcurrently,
+    membersToPartitionsRatio: options.membersToPartitionsRatio
+  } : void 0;
+  const kafka = ((_a = options.events) == null ? void 0 : _a.kafka) || legacyKafka;
+  const pulse = (_b = options.events) == null ? void 0 : _b.pulse;
+  if (!kafka && !pulse && !options.events) return void 0;
+  const defaultTransport = kafka ? "kafka" : pulse ? "pulse" : void 0;
+  return {
+    kafka,
+    pulse,
+    consumeFrom: ((_c = options.events) == null ? void 0 : _c.consumeFrom) || (defaultTransport ? [defaultTransport] : []),
+    publishTo: ((_d = options.events) == null ? void 0 : _d.publishTo) || defaultTransport
+  };
+}
+function createEventBus(options) {
+  const resolved = resolveEventsConfig(options);
+  if (!resolved) return void 0;
+  const transports = {};
+  if (resolved.kafka) transports.kafka = new KafkaManager_default(resolved.kafka);
+  if (resolved.pulse) transports.pulse = new PulseManager(resolved.pulse);
+  return new EventBus({
+    echoes: options.echoes,
+    transports,
+    consumeFrom: resolved.consumeFrom,
+    publishTo: resolved.publishTo
+  });
+}
+
+// src/requestsHandler/getEcho.ts
+function getEcho_default(method) {
+  const echo2 = config_default.echoes[method];
+  if (!echo2) {
+    throw new Error(`Echo named ${method} not found in this service`);
+  }
+  if (echo2.type !== "request") {
+    throw new Error(`Echo named ${method} is not of type request`);
+  }
+  return echo2;
+}
+
+// src/request/getSignature.ts
+var import_jssha = __toESM(require("jssha"), 1);
+
+// src/request/getPassword.ts
+var import_logger3 = require("@orion-js/logger");
+var import_env = require("@orion-js/env");
+function getEchoesPassword() {
+  var _a, _b;
+  const secret = ((_b = (_a = config_default) == null ? void 0 : _a.requests) == null ? void 0 : _b.key) || (0, import_env.internalGetEnv)("echoes_password", "ECHOES_PASSWORD");
+  if (!secret) {
+    import_logger3.logger.warn(
+      'Warning: no secret key found for echoes requests. Init echoes or set the env var "echoes_password" or process.env.ECHOES_PASSWORD'
+    );
+  }
+  return secret;
+}
+
+// src/request/getSignature.ts
+function getSignature_default(body) {
+  const password = getEchoesPassword();
+  const shaObj = new import_jssha.default("SHA-1", "TEXT");
+  shaObj.setHMACKey(password, "TEXT");
+  shaObj.update(body);
+  return shaObj.getHMAC("HEX");
+}
+
+// src/requestsHandler/checkSignature.ts
+function checkSignature_default(body, signature) {
+  const generatedSignature = getSignature_default(body);
+  if (generatedSignature !== signature) {
+    throw new Error("Echoes invalid signature");
+  }
+}
+
+// src/requestsHandler/index.ts
+var import_http = require("@orion-js/http");
+var requestsHandler_default = (options) => (0, import_http.route)({
+  method: "post",
+  path: options.requests.handlerPath || "/echoes-services",
+  bodyParser: "json",
+  bodyParserOptions: {
+    limit: "10mb"
+  },
+  async resolve(req) {
+    try {
+      const { body, signature } = req.body;
+      checkSignature_default(body, signature);
+      const { method, serializedParams } = body;
+      const echo2 = getEcho_default(method);
+      const result = await echo2.onRequest(serializedParams);
+      return {
+        body: {
+          result: serialize_default(result)
+        }
+      };
+    } catch (error) {
+      if (!error.getInfo) {
+        console.error("Error at echo requests handler:", error);
+      }
+      return {
+        body: {
+          error: error.message,
+          errorInfo: error.getInfo ? error.getInfo() : null,
+          isValidationError: !!error.isValidationError,
+          isUserError: !!error.isUserError
+        }
+      };
+    }
+  }
+});
+
 // src/startService/index.ts
-var import_http2 = require("@orion-js/http");
-var kafkaManager = null;
+var eventBus = null;
 async function startService(options) {
   config_default.echoes = options.echoes;
   if (options.requests) {
     config_default.requests = options.requests;
     (0, import_http2.registerRoute)(requestsHandler_default(options));
   }
-  if (options.client) {
-    kafkaManager = new KafkaManager_default(options);
-    await kafkaManager.start();
-    config_default.producer = kafkaManager.producer;
-    config_default.consumer = kafkaManager.consumer;
+  const nextEventBus = createEventBus(options);
+  if (nextEventBus) {
+    await nextEventBus.start();
+    eventBus = nextEventBus;
+    config_default.eventBus = eventBus;
   }
 }
 async function stopService() {
-  if (kafkaManager) {
+  if (eventBus) {
     console.info("Stoping echoes...");
-    await kafkaManager.stop();
+    await eventBus.close();
+    eventBus = null;
+    config_default.eventBus = void 0;
     console.info("Echoes stopped");
   }
 }
 
 // src/publish/index.ts
 async function publish(options) {
-  if (!config_default.producer) {
-    throw new Error("You must initialize echoes configruation to use publish");
+  if (!config_default.eventBus) {
+    throw new Error("You must initialize echoes configuration to use publish");
   }
-  const payload = {
-    params: options.params
-  };
-  return await config_default.producer.send({
-    acks: options.acks,
-    timeout: options.timeout,
-    topic: options.topic,
-    messages: [
-      {
-        value: serialize_default(payload)
-      }
-    ]
-  });
+  return await config_default.eventBus.publish(options);
 }
 
 // src/request/getURL.ts
@@ -343,15 +605,6 @@ function getURL_default(serviceName) {
   return url;
 }
 
-// src/echo/deserialize.ts
-function deserialize_default(serializedJavascript) {
-  try {
-    return eval("(" + serializedJavascript + ")");
-  } catch (error) {
-    throw new Error("Error deserializing echo message");
-  }
-}
-
 // src/request/makeRequest.ts
 var import_axios = __toESM(require("axios"), 1);
 var import_helpers2 = require("@orion-js/helpers");
@@ -424,7 +677,7 @@ async function request(options) {
 }
 
 // src/service/index.ts
-var import_logger3 = require("@orion-js/logger");
+var import_logger4 = require("@orion-js/logger");
 
 // src/echo/index.ts
 var import_schema2 = require("@orion-js/schema");
@@ -437,20 +690,44 @@ var echo = function createNewEcho(options) {
     }
     return result;
   };
+  const onEvent = async (event) => {
+    const context = {
+      ...event.context || {},
+      transport: event.transport,
+      eventId: event.id,
+      topic: event.topic,
+      headers: event.headers,
+      createdAt: event.createdAt,
+      attempt: event.attempt,
+      data: event.data
+    };
+    await resolve(event.data.params, context);
+  };
   return {
     type: options.type,
     params: options.params,
     returns: options.returns,
     attemptsBeforeDeadLetter: options.type === "event" ? options.attemptsBeforeDeadLetter : void 0,
     resolve,
+    onEvent,
     onMessage: async (messageData) => {
+      var _a, _b, _c, _d;
       const { message } = messageData;
       const data = deserialize_default(message.value.toString());
-      const context = {
-        ...messageData,
-        data
-      };
-      await resolve(data.params, context);
+      const retries = Number.parseInt(((_b = (_a = message.headers) == null ? void 0 : _a.retries) == null ? void 0 : _b.toString()) || "0", 10);
+      const timestamp = Number(message.timestamp);
+      const createdAt = Number.isFinite(timestamp) ? new Date(timestamp) : /* @__PURE__ */ new Date();
+      const eventId = ((_d = (_c = message.headers) == null ? void 0 : _c["echoes-event-id"]) == null ? void 0 : _d.toString()) || `kafka:${messageData.topic}:${messageData.partition}:${message.offset}`;
+      await onEvent({
+        id: eventId,
+        topic: messageData.topic,
+        data,
+        transport: "kafka",
+        headers: message.headers,
+        createdAt,
+        attempt: retries + 1,
+        context: messageData
+      });
     },
     onRequest: async (serializedParams) => {
       const context = {};
@@ -491,7 +768,7 @@ function EchoEvent(options = {}) {
         return createEchoEvent({
           ...options,
           resolve: async (params, contextData) => {
-            return await (0, import_logger3.runWithOrionAsyncContext)(
+            return await (0, import_logger4.runWithOrionAsyncContext)(
               {
                 controllerType: "echo",
                 echoName: propertyKey,
@@ -520,7 +797,7 @@ function EchoRequest(options = {}) {
         return createEchoRequest({
           ...options,
           resolve: async (params, contextData) => {
-            return await (0, import_logger3.runWithOrionAsyncContext)(
+            return await (0, import_logger4.runWithOrionAsyncContext)(
               {
                 controllerType: "echo",
                 echoName: propertyKey,