@orion-js/echoes 4.4.0 → 4.5.0

package/dist/index.cjs

@@ -32,14 +32,26 @@ __export(index_exports, {
   EchoEvent: () => EchoEvent,
   EchoRequest: () => EchoRequest,
   Echoes: () => Echoes,
+  EchoesUserError: () => EchoesUserError,
+  EchoesValidationError: () => EchoesValidationError,
+  cleanEchoesSchema: () => cleanEchoesSchema,
+  configureEchoesRuntime: () => configureEchoesRuntime,
   createEchoEvent: () => createEchoEvent,
   createEchoRequest: () => createEchoRequest,
+  createEchoesUserError: () => createEchoesUserError,
+  createEchoesValidationError: () => createEchoesValidationError,
   echo: () => echo,
+  getEchoesContext: () => getEchoesContext,
+  getEchoesLogger: () => getEchoesLogger,
+  getEchoesRuntime: () => getEchoesRuntime,
   getServiceEchoes: () => getServiceEchoes,
+  parseEchoesSchema: () => parseEchoesSchema,
   publish: () => publish,
   request: () => request,
+  runWithEchoesContext: () => runWithEchoesContext,
   startService: () => startService,
-  stopService: () => stopService
+  stopService: () => stopService,
+  typedEchoesSchema: () => typedEchoesSchema
 });
 module.exports = __toCommonJS(index_exports);
 
@@ -47,38 +59,175 @@ module.exports = __toCommonJS(index_exports);
 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`);
+// src/publish/index.ts
+async function publish(options) {
+  if (!config_default.eventBus) {
+    throw new Error("You must initialize echoes configuration to use publish");
   }
-  if (echo2.type !== "request") {
-    throw new Error(`Echo named ${method} is not of type request`);
+  return await config_default.eventBus.publish(options);
+}
+
+// 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
 var import_serialize_javascript = __toESM(require("serialize-javascript"), 1);
-var import_helpers = require("@orion-js/helpers");
 function serialize_default(data) {
-  const cloned = (0, import_helpers.clone)(data);
-  const serialized = (0, import_serialize_javascript.default)(cloned, { ignoreFunction: true });
+  const serialized = (0, import_serialize_javascript.default)(data, { ignoreFunction: true });
   return serialized;
 }
 
+// src/runtime.ts
+var import_node_async_hooks = require("async_hooks");
+var import_node_crypto = require("crypto");
+
+// src/errors.ts
+var EchoesUserError = class extends Error {
+  isEchoesError = true;
+  isOrionError = true;
+  isUserError = true;
+  code;
+  extra;
+  constructor(code, message, extra) {
+    if (!message) {
+      message = code;
+      code = "error";
+    }
+    super(message);
+    this.name = "EchoesUserError";
+    this.code = code;
+    this.extra = extra;
+  }
+  getInfo() {
+    return { error: this.code, message: this.message, extra: this.extra };
+  }
+};
+var EchoesValidationError = class extends Error {
+  isEchoesError = true;
+  isOrionError = true;
+  isValidationError = true;
+  code = "validationError";
+  validationErrors;
+  labels;
+  constructor(validationErrors, labels = {}) {
+    const printableErrors = Object.entries(validationErrors).map(([key, value]) => `${key}: ${value}`).join(", ");
+    super(`Validation Error: {${printableErrors}}`);
+    this.name = "EchoesValidationError";
+    this.validationErrors = validationErrors;
+    this.labels = Object.fromEntries(
+      Object.keys(validationErrors).filter((key) => labels[key]).map((key) => [key, labels[key]])
+    );
+  }
+  getInfo() {
+    return {
+      error: this.code,
+      message: "Validation Error",
+      validationErrors: this.validationErrors,
+      labels: this.labels
+    };
+  }
+};
+
+// src/runtime.ts
+var defaultLogger = {
+  debug: (message, metadata) => metadata === void 0 ? console.debug(message) : console.debug(message, metadata),
+  info: (message, metadata) => metadata === void 0 ? console.info(message) : console.info(message, metadata),
+  warn: (message, metadata) => metadata === void 0 ? console.warn(message) : console.warn(message, metadata),
+  error: (message, metadata) => metadata === void 0 ? console.error(message) : console.error(message, metadata)
+};
+var runtime = {};
+var contextStorage = new import_node_async_hooks.AsyncLocalStorage();
+function configureEchoesRuntime(adapter) {
+  const previous = runtime;
+  runtime = { ...runtime, ...adapter };
+  return () => {
+    runtime = previous;
+  };
+}
+function getEchoesRuntime() {
+  return runtime;
+}
+function getEchoesLogger() {
+  return runtime.logger || defaultLogger;
+}
+function getEchoesContext() {
+  return contextStorage.getStore();
+}
+async function runWithEchoesContext(context, callback) {
+  const contextWithId = { contextId: context.contextId || (0, import_node_crypto.randomUUID)(), ...context };
+  return await contextStorage.run(contextWithId, async () => {
+    if (runtime.runWithContext) {
+      return await runtime.runWithContext(contextWithId, callback);
+    }
+    return await callback();
+  });
+}
+function isSimpleSchemaLike(schema) {
+  return !!schema && typeof schema === "object" && typeof schema.clean === "function" && typeof schema.validate === "function";
+}
+function cloneValue(value) {
+  if (value === null || typeof value !== "object") return value;
+  if (value instanceof Date) return new Date(value.getTime());
+  if (Buffer.isBuffer(value)) return Buffer.from(value);
+  if (Array.isArray(value)) return value.map(cloneValue);
+  const prototype = Object.getPrototypeOf(value);
+  if (prototype !== Object.prototype && prototype !== null) return value;
+  const result = {};
+  for (const [key, child] of Object.entries(value)) {
+    result[key] = cloneValue(child);
+  }
+  return result;
+}
+async function cleanSimpleSchema(schema, value) {
+  const cloned = cloneValue(value);
+  return await schema.clean(cloned, { mutate: false });
+}
+async function cleanEchoesSchema(schema, value) {
+  if (isSimpleSchemaLike(schema)) {
+    return await cleanSimpleSchema(schema, value);
+  }
+  if (runtime.schema) {
+    return await runtime.schema.clean(schema, value);
+  }
+  throw new Error(
+    "Echoes received a schema it cannot execute. Use a SimpleSchema-compatible object or configure an Echoes schema adapter."
+  );
+}
+async function parseEchoesSchema(schema, value) {
+  if (isSimpleSchemaLike(schema)) {
+    const cleaned = await cleanSimpleSchema(schema, value);
+    await schema.validate(cleaned);
+    return cleaned;
+  }
+  if (runtime.schema) {
+    return await runtime.schema.parse(schema, value);
+  }
+  throw new Error(
+    "Echoes received a schema it cannot execute. Use a SimpleSchema-compatible object or configure an Echoes schema adapter."
+  );
+}
+function createEchoesValidationError(info) {
+  return runtime.createValidationError ? runtime.createValidationError(info) : new EchoesValidationError(info.validationErrors || {}, info.labels);
+}
+function createEchoesUserError(info) {
+  return runtime.createUserError ? runtime.createUserError(info) : new EchoesUserError(info.error, info.message, info.extra);
+}
+
 // src/request/getSignature.ts
-var import_jssha = __toESM(require("jssha"), 1);
+var import_node_crypto2 = require("crypto");
 
 // 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");
+  const secret = ((_b = (_a = config_default) == null ? void 0 : _a.requests) == null ? void 0 : _b.key) || process.env.echoes_password || process.env.ECHOES_PASSWORD;
   if (!secret) {
-    import_logger.logger.warn(
+    getEchoesLogger().warn(
       'Warning: no secret key found for echoes requests. Init echoes or set the env var "echoes_password" or process.env.ECHOES_PASSWORD'
     );
   }
@@ -86,89 +235,244 @@ function getEchoesPassword() {
 }
 
 // src/request/getSignature.ts
-function getSignature_default(body) {
+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");
+  return (0, import_node_crypto2.createHmac)("sha1", password || "").update("").digest("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/request/getURL.ts
+function getURL_default(serviceName) {
+  var _a, _b, _c;
+  if (serviceName.startsWith("http")) return serviceName;
+  const url = (_c = (_b = (_a = config_default) == null ? void 0 : _a.requests) == null ? void 0 : _b.services) == null ? void 0 : _c[serviceName];
+  if (!url) {
+    throw new Error(`No URL found in echoes config for service ${serviceName}`);
   }
+  return url;
 }
 
-// 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)
+// src/request/makeRequest.ts
+var import_node_http = __toESM(require("http"), 1);
+var import_node_https = __toESM(require("https"), 1);
+async function executeWithRetries(callback, retries = 0, delayMs = 200) {
+  try {
+    return await callback();
+  } catch (error) {
+    if (retries <= 0) throw error;
+    await new Promise((resolve) => setTimeout(resolve, delayMs));
+    return await executeWithRetries(callback, retries - 1, delayMs);
+  }
+}
+async function postJSON(urlValue, data, timeout, redirectsRemaining = 5) {
+  const url = new URL(urlValue);
+  const body = JSON.stringify(data);
+  const transport = url.protocol === "https:" ? import_node_https.default : import_node_http.default;
+  return await new Promise((resolve, reject) => {
+    const request2 = transport.request(
+      url,
+      {
+        method: "POST",
+        headers: {
+          "User-Agent": "Orionjs-Echoes/1.1",
+          "Content-Type": "application/json",
+          "Content-Length": Buffer.byteLength(body)
         }
-      };
-    } catch (error) {
-      if (!error.getInfo) {
-        console.error("Error at echo requests handler:", error);
+      },
+      (response) => {
+        const chunks = [];
+        const statusCode = response.statusCode || 0;
+        if (statusCode >= 300 && statusCode < 400 && response.headers.location) {
+          response.resume();
+          if (redirectsRemaining <= 0) {
+            reject(new Error("Echoes request exceeded the redirect limit"));
+            return;
+          }
+          resolve(
+            postJSON(
+              new URL(response.headers.location, url).toString(),
+              data,
+              timeout,
+              redirectsRemaining - 1
+            )
+          );
+          return;
+        }
+        response.on("data", (chunk) => chunks.push(Buffer.from(chunk)));
+        response.on("end", () => {
+          try {
+            const responseBody = Buffer.concat(chunks).toString("utf8");
+            if (statusCode < 200 || statusCode >= 300) {
+              reject(new Error(`Request failed with status code ${statusCode}`));
+              return;
+            }
+            resolve({
+              statusCode,
+              data: responseBody ? JSON.parse(responseBody) : {}
+            });
+          } catch (error) {
+            reject(error);
+          }
+        });
       }
-      return {
-        body: {
-          error: error.message,
-          errorInfo: error.getInfo ? error.getInfo() : null,
-          isValidationError: !!error.isValidationError,
-          isUserError: !!error.isUserError
+    );
+    request2.on("error", reject);
+    if (timeout) {
+      request2.setTimeout(timeout, () => {
+        request2.destroy(new Error(`Echoes request timed out after ${timeout}ms`));
+      });
+    }
+    request2.end(body);
+  });
+}
+var makeRequest = async (options) => {
+  return await executeWithRetries(
+    () => postJSON(options.url, options.data, options.timeout),
+    options.retries || 0
+  );
+};
+
+// src/request/index.ts
+async function request(options) {
+  var _a, _b;
+  const { method, service, params } = options;
+  const serializedParams = serialize_default(params);
+  const date = /* @__PURE__ */ new Date();
+  const body = { method, service, serializedParams, date };
+  const signature = getSignature_default(body);
+  try {
+    const requestMaker = ((_b = (_a = config_default) == null ? void 0 : _a.requests) == null ? void 0 : _b.makeRequest) || makeRequest;
+    const requestOptions = {
+      url: getURL_default(service),
+      retries: options.retries,
+      timeout: options.timeout,
+      data: {
+        body,
+        signature
+      }
+    };
+    const result = await requestMaker(requestOptions);
+    if (result.statusCode !== 200) {
+      throw new Error(`Wrong status code ${result.statusCode}`);
+    }
+    const data = result.data;
+    if (data.error) {
+      const info = data.errorInfo;
+      if (info) {
+        if (data.isValidationError) {
+          throw createEchoesValidationError(info);
         }
-      };
+        if (data.isUserError) {
+          throw createEchoesUserError(info);
+        }
+      }
+      throw new Error(`${data.error}`);
     }
+    const response = deserialize_default(data.result);
+    return response;
+  } catch (error) {
+    const caught = error;
+    if (caught.isOrionError || caught.isEchoesError) throw caught;
+    throw new Error(`Echoes request network error calling ${service}/${method}: ${caught.message}`);
   }
-});
+}
 
 // src/startService/KafkaManager.ts
-var import_kafkajs = require("kafkajs");
-var import_logger2 = require("@orion-js/logger");
+var import_node_crypto3 = require("crypto");
 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;
+    let kafkaModule;
+    try {
+      kafkaModule = await import("kafkajs");
+    } catch (error) {
+      const wrapped = new Error(
+        "Echoes Kafka transport requires kafkajs to be installed in the application"
+      );
+      wrapped.cause = error;
+      throw wrapped;
+    }
+    this.kafka = new kafkaModule.Kafka(this.options.client);
+    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;
+    getEchoesLogger().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_crypto3.randomUUID)()
+          }
+        }
+      ]
+    });
+  }
+  async close() {
+    var _a, _b;
+    const logger = getEchoesLogger();
+    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 logger = getEchoesLogger();
     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`);
+        logger.info(`Echoes: Consumer group ${groupId} is empty, joining`);
         return true;
       }
       const topicsMetadata = await admin.fetchTopicMetadata({ topics: this.topics });
@@ -176,23 +480,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`
+      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`
+        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 });
+      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 });
+        logger.error("Echoes: Error disconnecting admin client", { error });
       });
     }
   }
@@ -209,67 +514,83 @@ 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 logger = getEchoesLogger();
+    const subscription = this.subscriptions.get(params.topic);
+    if (!subscription) {
+      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}`);
+        logger.warn(`Echoes: Error sending heartbeat: ${error.message}`);
       });
       intervalsCount++;
       if (intervalsCount * HEARTBEAT_INTERVAL_SECONDS % 30 === 0) {
-        import_logger2.logger.warn(
+        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) {
+        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;
+    if (!message.value) {
+      throw new Error(`Echoes received an empty Kafka message for ${topic}`);
+    }
+    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 logger = getEchoesLogger();
     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;
+    if (!message.value) throw error;
     await this.producer.send({
       topic: nextTopic,
       messages: [
         {
           value: message.value.toString(),
           headers: {
+            ...message.headers,
             retries: String(retries + 1),
             error: error.message
           }
@@ -277,180 +598,339 @@ var KafkaManager = class {
       ]
     });
     if (exceededMaxRetries) {
-      import_logger2.logger.error(
+      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 });
+      logger.warn("Echoes: a retryable message failed", { error, topic: nextTopic });
     }
   }
 };
 var KafkaManager_default = KafkaManager;
 
-// src/startService/index.ts
-var import_http2 = require("@orion-js/http");
-var kafkaManager = 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));
+// src/events/EventBus.ts
+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;
   }
-  if (options.client) {
-    kafkaManager = new KafkaManager_default(options);
-    await kafkaManager.start();
-    config_default.producer = kafkaManager.producer;
-    config_default.consumer = kafkaManager.consumer;
+  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 function stopService() {
-  if (kafkaManager) {
-    console.info("Stoping echoes...");
-    await kafkaManager.stop();
-    console.info("Echoes stopped");
+  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 logger = getEchoesLogger();
+    const echo2 = this.echoes[event.topic];
+    if (!echo2 || echo2.type !== "event") {
+      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/publish/index.ts
-async function publish(options) {
-  if (!config_default.producer) {
-    throw new Error("You must initialize echoes configruation to use publish");
+// 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 }
+    };
   }
-  const payload = {
-    params: options.params
+  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
   };
-  return await config_default.producer.send({
-    acks: options.acks,
-    timeout: options.timeout,
-    topic: options.topic,
-    messages: [
-      {
-        value: serialize_default(payload)
-      }
-    ]
+}
+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/request/getURL.ts
-function getURL_default(serviceName) {
-  var _a, _b;
-  if (serviceName.startsWith("http")) return serviceName;
-  const url = (_b = (_a = config_default) == null ? void 0 : _a.requests) == null ? void 0 : _b.services[serviceName];
-  if (!url) {
-    throw new Error(`No URL found in echoes config for service ${serviceName}`);
+// src/requestsHandler/checkSignature.ts
+function checkSignature_default(body, signature) {
+  const generatedSignature = getSignature_default(body);
+  if (generatedSignature !== signature) {
+    throw new Error("Echoes invalid signature");
   }
-  return url;
 }
 
-// src/echo/deserialize.ts
-function deserialize_default(serializedJavascript) {
-  try {
-    return eval("(" + serializedJavascript + ")");
-  } catch (error) {
-    throw new Error("Error deserializing echo message");
+// 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/makeRequest.ts
-var import_axios = __toESM(require("axios"), 1);
-var import_helpers2 = require("@orion-js/helpers");
-var makeRequest = async (options) => {
-  const result = await (0, import_helpers2.executeWithRetries)(
-    async () => {
-      return await (0, import_axios.default)({
-        method: "post",
-        url: options.url,
-        timeout: options.timeout,
-        headers: {
-          "User-Agent": "Orionjs-Echoes/1.1"
-        },
-        data: options.data
-      });
-    },
-    options.retries,
-    200
-  );
-  return {
-    data: result.data,
-    statusCode: result.status
-  };
-};
-
-// src/request/index.ts
-var import_schema = require("@orion-js/schema");
-var import_helpers3 = require("@orion-js/helpers");
-async function request(options) {
-  var _a, _b;
-  const { method, service, params } = options;
-  const serializedParams = serialize_default(params);
-  const date = /* @__PURE__ */ new Date();
-  const body = { method, service, serializedParams, date };
-  const signature = getSignature_default(body);
-  try {
-    const requestMaker = ((_b = (_a = config_default) == null ? void 0 : _a.requests) == null ? void 0 : _b.makeRequest) || makeRequest;
-    const requestOptions = {
-      url: getURL_default(service),
-      retries: options.retries,
-      timeout: options.timeout,
-      data: {
-        body,
-        signature
+// src/requestsHandler/index.ts
+var requestsHandler_default = (options) => ({
+  method: "post",
+  path: options.requests.handlerPath || "/echoes-services",
+  bodyLimit: "10mb",
+  async handle(requestBody) {
+    try {
+      const { body, signature } = requestBody;
+      checkSignature_default(body, signature);
+      const { method, serializedParams } = body;
+      const echo2 = getEcho_default(method);
+      const result = await echo2.onRequest(serializedParams);
+      return { result: serialize_default(result) };
+    } catch (error) {
+      const caught = error;
+      if (!caught.getInfo) {
+        getEchoesLogger().error("Error at echo requests handler:", { error: caught });
       }
-    };
-    const result = await requestMaker(requestOptions);
-    if (result.statusCode !== 200) {
-      throw new Error(`Wrong status code ${result.statusCode}`);
+      return {
+        error: caught.message,
+        errorInfo: caught.getInfo ? caught.getInfo() : null,
+        isValidationError: !!caught.isValidationError,
+        isUserError: !!caught.isUserError
+      };
     }
-    const data = result.data;
-    if (data.error) {
-      const info = data.errorInfo;
-      if (info) {
-        if (data.isValidationError) {
-          throw new import_schema.ValidationError(info.validationErrors);
-        }
-        if (data.isUserError) {
-          throw new import_helpers3.UserError(info.error, info.message, info.extra);
-        }
-      }
-      throw new Error(`${data.error}`);
+  }
+});
+
+// src/startService/index.ts
+var eventBus = null;
+async function startService(options) {
+  config_default.echoes = options.echoes;
+  if (options.requests) {
+    config_default.requests = options.requests;
+    const registerHandler = options.requests.registerHandler || getEchoesRuntime().registerRequestHandler;
+    if (!registerHandler) {
+      throw new Error(
+        "Echoes requests require requests.registerHandler in standalone servers. Orion applications can import @orion-js/echoes-orion once during startup."
+      );
     }
-    const response = deserialize_default(data.result);
-    return response;
-  } catch (error) {
-    if (error.isOrionError) throw error;
-    throw new Error(`Echoes request network error calling ${service}/${method}: ${error.message}`);
+    await registerHandler(requestsHandler_default(options));
+  }
+  const nextEventBus = createEventBus(options);
+  if (nextEventBus) {
+    await nextEventBus.start();
+    eventBus = nextEventBus;
+    config_default.eventBus = eventBus;
+  }
+}
+async function stopService() {
+  if (eventBus) {
+    const logger = getEchoesLogger();
+    logger.info("Stopping Echoes...");
+    await eventBus.close();
+    eventBus = null;
+    config_default.eventBus = void 0;
+    logger.info("Echoes stopped");
   }
 }
-
-// src/service/index.ts
-var import_logger3 = require("@orion-js/logger");
 
 // src/echo/index.ts
-var import_schema2 = require("@orion-js/schema");
 var echo = function createNewEcho(options) {
   const resolve = async (params, context) => {
-    const cleaned = options.params ? await (0, import_schema2.cleanAndValidate)(options.params, params) : params ?? {};
+    const cleaned = options.params ? await parseEchoesSchema(options.params, params) : params ?? {};
     const result = await options.resolve(cleaned, context);
     if (options.returns) {
-      return await (0, import_schema2.clean)(options.returns, result);
+      return await cleanEchoesSchema(options.returns, result);
     }
     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;
+      if (!message.value) {
+        throw new Error(`Echoes received an empty Kafka message for ${messageData.topic}`);
+      }
       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 = {};
@@ -466,15 +946,21 @@ function createEchoEvent(options) {
   return echo({ ...options, type: "event" });
 }
 
+// src/schema.ts
+function typedEchoesSchema(schema) {
+  return schema;
+}
+
 // src/service/index.ts
-var import_services = require("@orion-js/services");
 var serviceMetadata = /* @__PURE__ */ new WeakMap();
 var echoesMetadata = /* @__PURE__ */ new WeakMap();
 var echoEntriesByClass = /* @__PURE__ */ new Map();
+var standaloneInstances = /* @__PURE__ */ new WeakMap();
 var pendingEchoEntries = {};
 function Echoes() {
   return (target, context) => {
-    (0, import_services.Service)()(target, context);
+    var _a, _b;
+    (_b = (_a = getEchoesRuntime()).decorateService) == null ? void 0 : _b.call(_a, target, context);
     serviceMetadata.set(target, { _serviceType: "echoes" });
     if (Object.keys(pendingEchoEntries).length > 0) {
       echoEntriesByClass.set(target, pendingEchoEntries);
@@ -491,7 +977,7 @@ function EchoEvent(options = {}) {
         return createEchoEvent({
           ...options,
           resolve: async (params, contextData) => {
-            return await (0, import_logger3.runWithOrionAsyncContext)(
+            return await runWithEchoesContext(
               {
                 controllerType: "echo",
                 echoName: propertyKey,
@@ -520,7 +1006,7 @@ function EchoRequest(options = {}) {
         return createEchoRequest({
           ...options,
           resolve: async (params, contextData) => {
-            return await (0, import_logger3.runWithOrionAsyncContext)(
+            return await runWithEchoesContext(
               {
                 controllerType: "echo",
                 echoName: propertyKey,
@@ -550,7 +1036,18 @@ function initializeEchoesIfNeeded(instance) {
   echoesMetadata.set(instance, echoes);
 }
 function getServiceEchoes(target) {
-  const instance = (0, import_services.getInstance)(target);
+  let instance;
+  if (typeof target !== "function") {
+    instance = target;
+  } else if (getEchoesRuntime().getInstance) {
+    instance = getEchoesRuntime().getInstance(target);
+  } else {
+    instance = standaloneInstances.get(target);
+    if (!instance) {
+      instance = new target();
+      standaloneInstances.set(target, instance);
+    }
+  }
   if (!serviceMetadata.has(instance.constructor)) {
     throw new Error("You must pass a class decorated with @Echoes to getServiceEchoes");
   }
@@ -567,13 +1064,25 @@ function getServiceEchoes(target) {
   EchoEvent,
   EchoRequest,
   Echoes,
+  EchoesUserError,
+  EchoesValidationError,
+  cleanEchoesSchema,
+  configureEchoesRuntime,
   createEchoEvent,
   createEchoRequest,
+  createEchoesUserError,
+  createEchoesValidationError,
   echo,
+  getEchoesContext,
+  getEchoesLogger,
+  getEchoesRuntime,
   getServiceEchoes,
+  parseEchoesSchema,
   publish,
   request,
+  runWithEchoesContext,
   startService,
-  stopService
+  stopService,
+  typedEchoesSchema
 });
 //# sourceMappingURL=index.cjs.map