@orion-js/echoes 4.5.5 → 4.5.7

package/dist/index.js

@@ -699,10 +699,14 @@ var EventBus = class {
     const subscriptions = Object.entries(this.echoes).filter(([, echo2]) => echo2.type === "event").map(([topic, echo2]) => ({
       topic,
       attemptsBeforeDeadLetter: echo2.attemptsBeforeDeadLetter,
-      ordered: echo2.ordered,
       configVersion: echo2.configVersion,
-      executionVersion: echo2.executionVersion
+      maxConcurrency: echo2.maxConcurrency,
+      receiverMode: echo2.receiverMode ?? "single",
+      batchSize: echo2.batchSize ?? 1
     }));
+    if (this.consumeFrom.includes("kafka") && subscriptions.some((subscription) => subscription.receiverMode === "batch")) {
+      throw new Error("Echoes batch event receivers are supported only by the Pulse transport.");
+    }
     try {
       for (const name of selected) {
         const transport = this.transports[name];
@@ -711,7 +715,8 @@ var EventBus = class {
           consume: this.consumeFrom.includes(name),
           publish: this.publishTo === name,
           subscriptions,
-          onEvent: (event) => this.handleEvent(event)
+          onEvent: (event) => this.handleEvent(event),
+          onEvents: (events) => this.handleEvents(events)
         });
       }
       this.started = true;
@@ -760,6 +765,15 @@ var EventBus = class {
       data: event.data
     });
   }
+  async handleEvents(events) {
+    if (events.length === 0) return;
+    const echo2 = this.echoes[events[0].topic];
+    if ((echo2 == null ? void 0 : echo2.type) === "event" && echo2.onEvents) {
+      await echo2.onEvents(events);
+      return;
+    }
+    for (const event of events) await this.handleEvent(event);
+  }
 };
 
 // src/events/PulseManager.ts
@@ -789,18 +803,23 @@ var PulseManager = class {
     this.subscriptions = await Promise.all(
       options.subscriptions.map(async (definition) => {
         const subscribeOptions = this.getSubscribeOptions(subscription, definition);
-        const active = await this.pulse.subscribe(
+        if (definition.receiverMode === "batch") {
+          if (typeof this.pulse.subscribeBatch !== "function") {
+            throw new Error(
+              "Echoes batch event receivers require a version of @orion-js/pulse with subscribeBatch support."
+            );
+          }
+          return await this.pulse.subscribeBatch(
+            definition.topic,
+            (events) => options.onEvents(events.map((event) => this.createReceivedEvent(event))),
+            { ...subscribeOptions, batchSize: definition.batchSize }
+          );
+        }
+        return await this.pulse.subscribe(
           definition.topic,
           (event) => options.onEvent(this.createReceivedEvent(event)),
           subscribeOptions
         );
-        if (subscribeOptions.executionVersion === 2 && active.executionVersion !== 2) {
-          await active.unsubscribe();
-          throw new Error(
-            "Echoes executionVersion 2 requires a bridge-capable @orion-js/pulse version and a winning configVersion for this listener."
-          );
-        }
-        return active;
       })
     );
   }
@@ -821,10 +840,9 @@ var PulseManager = class {
   getSubscribeOptions(defaults = {}, definition) {
     return {
       ...defaults,
-      ...definition.ordered === void 0 ? {} : { ordered: definition.ordered },
       ...definition.configVersion === void 0 ? {} : { configVersion: definition.configVersion },
-      ...definition.executionVersion === void 0 ? {} : { executionVersion: definition.executionVersion },
-      ...definition.attemptsBeforeDeadLetter === void 0 ? {} : { maxRetries: definition.attemptsBeforeDeadLetter }
+      ...definition.attemptsBeforeDeadLetter === void 0 ? {} : { maxRetries: definition.attemptsBeforeDeadLetter },
+      ...definition.maxConcurrency === void 0 ? {} : { maxConcurrency: definition.maxConcurrency }
     };
   }
   createReceivedEvent(event) {
@@ -958,6 +976,18 @@ async function stopService() {
 }
 
 // src/echo/index.ts
+function receivedEventContext(event) {
+  return {
+    ...event.context || {},
+    transport: event.transport,
+    eventId: event.id,
+    topic: event.topic,
+    headers: event.headers,
+    createdAt: event.createdAt,
+    attempt: event.attempt,
+    data: event.data
+  };
+}
 var echo = function createNewEcho(options) {
   const resolve = async (params, context) => {
     const cleaned = options.params ? await parseEchoesSchema(options.params, params) : params ?? {};
@@ -968,26 +998,17 @@ 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);
+    await resolve(event.data.params, receivedEventContext(event));
   };
   return {
     type: options.type,
     params: options.params,
     returns: options.returns,
     attemptsBeforeDeadLetter: options.type === "event" ? options.attemptsBeforeDeadLetter : void 0,
-    ordered: options.type === "event" ? options.ordered : void 0,
     configVersion: options.type === "event" ? options.configVersion : void 0,
-    executionVersion: options.type === "event" ? options.executionVersion : void 0,
+    maxConcurrency: options.type === "event" ? options.maxConcurrency : void 0,
+    receiverMode: options.type === "event" ? "single" : void 0,
+    batchSize: options.type === "event" ? 1 : void 0,
     resolve,
     onEvent,
     onMessage: async (messageData) => {
@@ -1025,6 +1046,50 @@ function createEchoRequest(options) {
 function createEchoEvent(options) {
   return echo({ ...options, type: "event" });
 }
+function createEchoBatchEvent(options) {
+  if (!Number.isInteger(options.batchSize) || options.batchSize <= 0) {
+    throw new Error("batchSize must be a positive integer.");
+  }
+  const resolveBatch = async (events) => {
+    const cleaned = await Promise.all(
+      events.map(async (event) => ({
+        params: options.params ? await parseEchoesSchema(options.params, event.params) : event.params ?? {},
+        context: event.context
+      }))
+    );
+    await options.resolveBatch(cleaned);
+  };
+  const onEvents = async (events) => {
+    await resolveBatch(
+      events.map((event) => ({
+        params: event.data.params,
+        context: receivedEventContext(event)
+      }))
+    );
+  };
+  return {
+    type: "event",
+    params: options.params,
+    attemptsBeforeDeadLetter: options.attemptsBeforeDeadLetter,
+    configVersion: options.configVersion,
+    maxConcurrency: options.maxConcurrency,
+    receiverMode: "batch",
+    batchSize: options.batchSize,
+    resolve: async (params, context) => {
+      await resolveBatch([{ params, context: context ?? {} }]);
+      return void 0;
+    },
+    resolveBatch,
+    onEvent: async (event) => await onEvents([event]),
+    onEvents,
+    onMessage: async () => {
+      throw new Error("Echoes batch event receivers are supported only by the Pulse transport.");
+    },
+    onRequest: async () => {
+      throw new Error("Echoes batch events cannot be invoked as requests.");
+    }
+  };
+}
 
 // src/schema.ts
 function typedEchoesSchema(schema) {
@@ -1077,6 +1142,28 @@ function EchoEvent(options = {}) {
     return method;
   };
 }
+function EchoBatchEvent(options) {
+  return (method, context) => {
+    const propertyKey = String(context.name);
+    pendingEchoEntries[propertyKey] = (instance) => {
+      const originalResolveBatch = instance[propertyKey].bind(instance);
+      return createEchoBatchEvent({
+        ...options,
+        resolveBatch: async (events) => {
+          return await runWithEchoesContext(
+            {
+              controllerType: "echo",
+              echoName: propertyKey,
+              params: events.map((event) => event.params)
+            },
+            async () => await originalResolveBatch(events)
+          );
+        }
+      });
+    };
+    return method;
+  };
+}
 function EchoRequest(options = {}) {
   return (method, context) => {
     const propertyKey = String(context.name);
@@ -1140,6 +1227,7 @@ function getServiceEchoes(target) {
   return echoesMap;
 }
 export {
+  EchoBatchEvent,
   EchoEvent,
   EchoRequest,
   Echoes,
@@ -1147,6 +1235,7 @@ export {
   EchoesValidationError,
   cleanEchoesSchema,
   configureEchoesRuntime,
+  createEchoBatchEvent,
   createEchoEvent,
   createEchoRequest,
   createEchoesUserError,