@orion-js/echoes 4.5.5 → 4.5.7

package/dist/echo/index.d.ts

@@ -1,9 +1,10 @@
 import type { EchoesSchema } from '../schema';
-import { EchoConfig, EchoEventConfig, EchoRequestConfig, EchoType } from '../types';
+import { EchoBatchEventConfig, EchoConfig, EchoEventConfig, EchoRequestConfig, EchoType } from '../types';
 /**
  * @deprecated Use createEchoRequest and createEchoEvent instead
  */
 declare const echo: <TParamsSchema extends EchoesSchema, TReturnsSchema extends EchoesSchema, TEchoType extends 'event' | 'request'>(options: EchoConfig<TParamsSchema, TReturnsSchema, TEchoType>) => EchoType<TParamsSchema, TReturnsSchema, TEchoType>;
 export declare function createEchoRequest<TParamsSchema extends EchoesSchema, TReturnsSchema extends EchoesSchema>(options: EchoRequestConfig<TParamsSchema, TReturnsSchema>): EchoType<TParamsSchema, TReturnsSchema, 'request'>;
 export declare function createEchoEvent<TParamsSchema extends EchoesSchema, TReturnsSchema extends EchoesSchema>(options: EchoEventConfig<TParamsSchema, TReturnsSchema>): EchoType<TParamsSchema, TReturnsSchema, 'event'>;
+export declare function createEchoBatchEvent<TParamsSchema extends EchoesSchema = any>(options: EchoBatchEventConfig<TParamsSchema>): EchoType<TParamsSchema, any, 'event'>;
 export { echo };

package/dist/events/EventBus.d.ts

@@ -19,4 +19,5 @@ export default class EventBus {
     publish<TParams = any>(options: PublishOptions<TParams>): Promise<any>;
     close(): Promise<void>;
     private handleEvent;
+    private handleEvents;
 }

package/dist/events/EventTransport.d.ts

@@ -2,15 +2,17 @@ import type { EchoesEventTransportName, EchoesReceivedEvent, PublishOptions } fr
 export interface EventSubscriptionDefinition {
     topic: string;
     attemptsBeforeDeadLetter?: number;
-    ordered?: boolean;
     configVersion?: number;
-    executionVersion?: 1 | 2;
+    maxConcurrency?: number;
+    receiverMode: 'single' | 'batch';
+    batchSize: number;
 }
 export interface EventTransportStartOptions {
     consume: boolean;
     publish: boolean;
     subscriptions: EventSubscriptionDefinition[];
     onEvent(event: EchoesReceivedEvent): Promise<void>;
+    onEvents(events: EchoesReceivedEvent[]): Promise<void>;
 }
 export interface EventTransport {
     readonly name: EchoesEventTransportName;

package/dist/index.cjs

@@ -29,6 +29,7 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
+  EchoBatchEvent: () => EchoBatchEvent,
   EchoEvent: () => EchoEvent,
   EchoRequest: () => EchoRequest,
   Echoes: () => Echoes,
@@ -36,6 +37,7 @@ __export(index_exports, {
   EchoesValidationError: () => EchoesValidationError,
   cleanEchoesSchema: () => cleanEchoesSchema,
   configureEchoesRuntime: () => configureEchoesRuntime,
+  createEchoBatchEvent: () => createEchoBatchEvent,
   createEchoEvent: () => createEchoEvent,
   createEchoRequest: () => createEchoRequest,
   createEchoesUserError: () => createEchoesUserError,
@@ -756,10 +758,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];
@@ -768,7 +774,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;
@@ -817,6 +824,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
@@ -846,18 +862,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;
       })
     );
   }
@@ -878,10 +899,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) {
@@ -1015,6 +1035,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 ?? {};
@@ -1025,26 +1057,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) => {
@@ -1082,6 +1105,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) {
@@ -1134,6 +1201,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);
@@ -1198,6 +1287,7 @@ function getServiceEchoes(target) {
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  EchoBatchEvent,
   EchoEvent,
   EchoRequest,
   Echoes,
@@ -1205,6 +1295,7 @@ function getServiceEchoes(target) {
   EchoesValidationError,
   cleanEchoesSchema,
   configureEchoesRuntime,
+  createEchoBatchEvent,
   createEchoEvent,
   createEchoRequest,
   createEchoesUserError,