@orion-js/echoes 4.4.1 → 4.5.0

package/dist/index.cjs

@@ -32,28 +32,40 @@ __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);
 
-// src/startService/index.ts
-var import_http2 = require("@orion-js/http");
-
 // src/config.ts
 var config = {};
 var config_default = config;
 
-// src/startService/KafkaManager.ts
-var import_node_crypto = require("crypto");
-var import_logger = require("@orion-js/logger");
-var import_kafkajs = require("kafkajs");
+// src/publish/index.ts
+async function publish(options) {
+  if (!config_default.eventBus) {
+    throw new Error("You must initialize echoes configuration to use publish");
+  }
+  return await config_default.eventBus.publish(options);
+}
 
 // src/echo/deserialize.ts
 function deserialize_default(serializedJavascript) {
@@ -66,14 +78,306 @@ function deserialize_default(serializedJavascript) {
 
 // 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_node_crypto2 = require("crypto");
+
+// src/request/getPassword.ts
+function getEchoesPassword() {
+  var _a, _b;
+  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) {
+    getEchoesLogger().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();
+  return (0, import_node_crypto2.createHmac)("sha1", password || "").update("").digest("hex");
+}
+
+// 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/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)
+        }
+      },
+      (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);
+          }
+        });
+      }
+    );
+    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_node_crypto3 = require("crypto");
 var HEARTBEAT_INTERVAL_SECONDS = 5;
 var CHECK_JOIN_CONSUMER_INTERVAL_SECONDS = 30;
 var DEFAULT_PARTITIONS_CONSUMED_CONCURRENTLY = 4;
@@ -91,11 +395,21 @@ var KafkaManager = class {
   producerConnected = false;
   interval;
   constructor(options) {
-    this.kafka = new import_kafkajs.Kafka(options.client);
     this.options = options;
   }
   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])
@@ -113,7 +427,7 @@ var KafkaManager = class {
     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");
+    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);
@@ -131,7 +445,7 @@ var KafkaManager = class {
         {
           value: serialize_default({ params: options.params }),
           headers: {
-            "echoes-event-id": (0, import_node_crypto.randomUUID)()
+            "echoes-event-id": (0, import_node_crypto3.randomUUID)()
           }
         }
       ]
@@ -139,7 +453,8 @@ var KafkaManager = class {
   }
   async close() {
     var _a, _b;
-    import_logger.logger.warn("Echoes: Stopping Kafka transport");
+    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(),
@@ -149,6 +464,7 @@ var KafkaManager = class {
     this.producerConnected = false;
   }
   async checkJoinConsumerGroupConditions() {
+    const logger = getEchoesLogger();
     const admin = this.kafka.admin();
     try {
       await admin.connect();
@@ -156,7 +472,7 @@ var KafkaManager = class {
       const groupDescriptions = await admin.describeGroups([groupId]);
       const group = groupDescriptions.groups[0];
       if (group.state === "Empty") {
-        import_logger.logger.info(`Echoes: Consumer group ${groupId} is empty, joining`);
+        logger.info(`Echoes: Consumer group ${groupId} is empty, joining`);
         return true;
       }
       const topicsMetadata = await admin.fetchTopicMetadata({ topics: this.topics });
@@ -164,24 +480,24 @@ var KafkaManager = class {
         (acc, topic) => acc + topic.partitions.length,
         0
       );
-      import_logger.logger.info(
+      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_logger.logger.info(
+        logger.info(
           `Echoes: Consumer group ${groupId} has room for more members ${group.members.length}/${partitionsThreshold}, joining`
         );
         return true;
       }
       return false;
     } catch (error) {
-      import_logger.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_logger.logger.error("Echoes: Error disconnecting admin client", { error });
+        logger.error("Echoes: Error disconnecting admin client", { error });
       });
     }
   }
@@ -201,19 +517,20 @@ var KafkaManager = class {
     return false;
   }
   async handleMessage(params) {
+    const logger = getEchoesLogger();
     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`);
+      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_logger.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_logger.logger.warn(
+        logger.warn(
           `Echoes: Event is taking too long to process: ${params.topic} ${intervalsCount * HEARTBEAT_INTERVAL_SECONDS}s`
         );
       }
@@ -225,7 +542,7 @@ var KafkaManager = class {
       try {
         await this.handleRetries(subscription, params, error);
       } catch (retryError) {
-        import_logger.logger.error("Echoes: error processing a message", {
+        logger.error("Echoes: error processing a message", {
           error: retryError,
           topic: params.topic
         });
@@ -238,6 +555,9 @@ var KafkaManager = class {
   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);
@@ -254,6 +574,7 @@ var KafkaManager = class {
   }
   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 (subscription.attemptsBeforeDeadLetter === void 0 || subscription.attemptsBeforeDeadLetter === null) {
@@ -262,6 +583,7 @@ var KafkaManager = class {
     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: [
@@ -276,19 +598,18 @@ var KafkaManager = class {
       ]
     });
     if (exceededMaxRetries) {
-      import_logger.logger.error(
+      logger.error(
         "Echoes: a message has reached the maximum number of retries, sending it to DLQ",
         { topic: nextTopic }
       );
     } else {
-      import_logger.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/events/EventBus.ts
-var import_logger2 = require("@orion-js/logger");
 var EventBus = class {
   echoes;
   transports;
@@ -348,9 +669,10 @@ var EventBus = class {
     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") {
-      import_logger2.logger.warn(`Echoes: Received a message for an unknown topic: ${event.topic}, ignoring it`);
+      logger.warn(`Echoes: Received a message for an unknown topic: ${event.topic}, ignoring it`);
       return;
     }
     if (event.transport === "kafka" && event.context) {
@@ -478,6 +800,14 @@ function createEventBus(options) {
   });
 }
 
+// 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/getEcho.ts
 function getEcho_default(method) {
   const echo2 = config_default.echoes[method];
@@ -490,72 +820,29 @@ function getEcho_default(method) {
   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)({
+var requestsHandler_default = (options) => ({
   method: "post",
   path: options.requests.handlerPath || "/echoes-services",
-  bodyParser: "json",
-  bodyParserOptions: {
-    limit: "10mb"
-  },
-  async resolve(req) {
+  bodyLimit: "10mb",
+  async handle(requestBody) {
     try {
-      const { body, signature } = req.body;
+      const { body, signature } = requestBody;
       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)
-        }
-      };
+      return { result: serialize_default(result) };
     } catch (error) {
-      if (!error.getInfo) {
-        console.error("Error at echo requests handler:", error);
+      const caught = error;
+      if (!caught.getInfo) {
+        getEchoesLogger().error("Error at echo requests handler:", { error: caught });
       }
       return {
-        body: {
-          error: error.message,
-          errorInfo: error.getInfo ? error.getInfo() : null,
-          isValidationError: !!error.isValidationError,
-          isUserError: !!error.isUserError
-        }
+        error: caught.message,
+        errorInfo: caught.getInfo ? caught.getInfo() : null,
+        isValidationError: !!caught.isValidationError,
+        isUserError: !!caught.isUserError
       };
     }
   }
@@ -567,7 +854,13 @@ async function startService(options) {
   config_default.echoes = options.echoes;
   if (options.requests) {
     config_default.requests = options.requests;
-    (0, import_http2.registerRoute)(requestsHandler_default(options));
+    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."
+      );
+    }
+    await registerHandler(requestsHandler_default(options));
   }
   const nextEventBus = createEventBus(options);
   if (nextEventBus) {
@@ -578,115 +871,22 @@ async function startService(options) {
 }
 async function stopService() {
   if (eventBus) {
-    console.info("Stoping echoes...");
+    const logger = getEchoesLogger();
+    logger.info("Stopping Echoes...");
     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.eventBus) {
-    throw new Error("You must initialize echoes configuration to use publish");
-  }
-  return await config_default.eventBus.publish(options);
-}
-
-// 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}`);
-  }
-  return url;
-}
-
-// 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
-      }
-    };
-    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 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}`);
-    }
-    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}`);
+    logger.info("Echoes stopped");
   }
 }
 
-// src/service/index.ts
-var import_logger4 = 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;
   };
@@ -713,6 +913,9 @@ var echo = function createNewEcho(options) {
     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 retries = Number.parseInt(((_b = (_a = message.headers) == null ? void 0 : _a.retries) == null ? void 0 : _b.toString()) || "0", 10);
       const timestamp = Number(message.timestamp);
@@ -743,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);
@@ -768,7 +977,7 @@ function EchoEvent(options = {}) {
         return createEchoEvent({
           ...options,
           resolve: async (params, contextData) => {
-            return await (0, import_logger4.runWithOrionAsyncContext)(
+            return await runWithEchoesContext(
               {
                 controllerType: "echo",
                 echoName: propertyKey,
@@ -797,7 +1006,7 @@ function EchoRequest(options = {}) {
         return createEchoRequest({
           ...options,
           resolve: async (params, contextData) => {
-            return await (0, import_logger4.runWithOrionAsyncContext)(
+            return await runWithEchoesContext(
               {
                 controllerType: "echo",
                 echoName: propertyKey,
@@ -827,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");
   }
@@ -844,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