arvo-event-handler 2.0.3 → 2.1.0

package/dist/ArvoEventHandler/index.js

@@ -14,6 +14,17 @@ var __extends = (this && this.__extends) || (function () {
         d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
     };
 })();
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
 var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
     function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
     return new (P || (P = Promise))(function (resolve, reject) {
@@ -55,168 +66,159 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 var arvo_core_1 = require("arvo-core");
-var schema_1 = require("arvo-core/dist/ArvoEvent/schema");
 var api_1 = require("@opentelemetry/api");
 var utils_1 = require("../utils");
 var AbstractArvoEventHandler_1 = __importDefault(require("../AbstractArvoEventHandler"));
-var OpenTelemetry_1 = require("../OpenTelemetry");
-var utils_2 = require("../OpenTelemetry/utils");
 /**
- * Represents an event handler for Arvo contracts.
- *
- * @template TContract - The type of ArvoContract this handler is associated with.
+ * ArvoEventHandler manages the execution and processing of events in accordance with
+ * Arvo contracts. This class serves as the cornerstone for event handling operations,
+ * integrating contract validation, telemetry management, and event processing.
  *
- * @remarks
- * This class is the core component for handling Arvo events. It encapsulates the logic
- * for executing event handlers, managing telemetry, and ensuring proper contract validation.
- * It's designed to be flexible and reusable across different Arvo contract implementations.
+ * The handler implements a robust execution flow that ensures proper validation,
+ * versioning, and error handling while maintaining detailed telemetry through
+ * OpenTelemetry integration. It supports versioned contracts and handles routing
+ * of both successful and error events.
  */
 var ArvoEventHandler = /** @class */ (function (_super) {
     __extends(ArvoEventHandler, _super);
     /**
-     * Creates an instance of ArvoEventHandler.
+     * Initializes a new ArvoEventHandler instance with the specified contract and configuration.
+     * Validates handler implementations against contract versions during initialization.
      *
-     * @param param - The configuration parameters for the event handler.
+     * The constructor ensures that handler implementations exist for all supported contract
+     * versions and configures OpenTelemetry span attributes for monitoring event handling.
      *
-     * @throws {Error} Throws an error if the provided source is invalid.
-     *
-     * @remarks
-     * The constructor validates the source parameter against the CloudEventContextSchema.
-     * If no source is provided, it defaults to the contract's accepted event type.
+     * @param param - Handler configuration including contract, execution units, and handler implementations
+     * @throws When handler implementations are missing for any contract version
      */
     function ArvoEventHandler(param) {
-        var _a, _b, _c, _d, _e, _f, _g;
+        var _a;
+        var _b, _c;
         var _this = _super.call(this) || this;
-        _this.openInferenceSpanKind = arvo_core_1.OpenInferenceSpanKind.CHAIN;
-        _this.arvoExecutionSpanKind = arvo_core_1.ArvoExecutionSpanKind.EVENT_HANDLER;
-        _this.openTelemetrySpanKind = api_1.SpanKind.INTERNAL;
         _this.contract = param.contract;
         _this.executionunits = param.executionunits;
-        _this._handler = param.handler;
-        if (param.source) {
-            var error = schema_1.CloudEventContextSchema.pick({
-                source: true,
-            }).safeParse({ source: param.source }).error;
-            if (error) {
-                throw new Error("The provided 'source' is not a valid string. Error: ".concat(error.message));
-            }
-        }
-        _this.source = (_a = param.source) !== null && _a !== void 0 ? _a : _this.contract.type;
-        _this.arvoExecutionSpanKind =
-            (_c = (_b = param.spanKind) === null || _b === void 0 ? void 0 : _b.arvoExecution) !== null && _c !== void 0 ? _c : _this.arvoExecutionSpanKind;
-        _this.openInferenceSpanKind =
-            (_e = (_d = param.spanKind) === null || _d === void 0 ? void 0 : _d.openInference) !== null && _e !== void 0 ? _e : _this.openInferenceSpanKind;
-        _this.openTelemetrySpanKind =
-            (_g = (_f = param.spanKind) === null || _f === void 0 ? void 0 : _f.openTelemetry) !== null && _g !== void 0 ? _g : _this.openTelemetrySpanKind;
-        for (var _i = 0, _h = Object.keys(_this.contract.versions); _i < _h.length; _i++) {
-            var contractVersions = _h[_i];
-            if (!_this._handler[contractVersions]) {
-                throw new Error("The event handler for contract (uri=".concat(_this.contract.uri, ") must contain a handler for version ").concat(contractVersions, "."));
+        _this.handler = param.handler;
+        for (var _i = 0, _d = Object.keys(_this.contract.versions); _i < _d.length; _i++) {
+            var contractVersions = _d[_i];
+            if (!_this.handler[contractVersions]) {
+                throw new Error("Contract ".concat(_this.contract.uri, " requires handler implementation for version ").concat(contractVersions));
             }
         }
+        _this.spanOptions = __assign(__assign({ kind: api_1.SpanKind.CONSUMER }, param.spanOptions), { attributes: __assign(__assign((_a = {}, _a[arvo_core_1.ArvoExecution.ATTR_SPAN_KIND] = arvo_core_1.ArvoExecutionSpanKind.EVENT_HANDLER, _a[arvo_core_1.OpenInference.ATTR_SPAN_KIND] = arvo_core_1.OpenInferenceSpanKind.CHAIN, _a), ((_c = (_b = param.spanOptions) === null || _b === void 0 ? void 0 : _b.attributes) !== null && _c !== void 0 ? _c : {})), { 'arvo.contract.uri': _this.contract.uri, 'arvo.handler.source': _this.source }) });
         return _this;
     }
+    Object.defineProperty(ArvoEventHandler.prototype, "source", {
+        /** The source identifier for events produced by this handler */
+        get: function () {
+            return this.contract.type;
+        },
+        enumerable: false,
+        configurable: true
+    });
     /**
-     * Executes the event handler for a given event.
-     *
-     * @param event - The event to handle.
-     * @param opentelemetry - Configuration for OpenTelemetry integration, including tracing options
-     *                        and context inheritance settings. Default is inherit from event and internal tracer
-     * @returns A promise that resolves to an array of resulting ArvoEvents.
-     *
-     * This method performs the following steps:
-     * 1. Creates an OpenTelemetry span for the execution.
-     * 2. Validates the input event against the contract.
-     * 3. Executes the handler function.
-     * 4. Creates and returns the result event(s).
-     * 5. Handles any errors and creates an error event if necessary.
-     *
-     * All telemetry data is properly set and propagated throughout the execution.
-     *
-     * @example
-     * ```typescript
-     * const contract = createArvoContract({ ... })
-     * const handler = createArvoEventHandler({
-     *    contract: contract,
-     *    ...
-     * });
-     * const inputEvent: ArvoEvent<...> = createArvoEvent({ ... });
-     * const resultEvents = await handler.execute(inputEvent);
-     * ```
+     * Processes an event according to the contract specifications. The execution flow encompasses
+     * span management, validation, handler execution, and error processing phases.
      *
-     * @throws All error throw during the execution are returned as a system error event
+     * Event Routing Logic:
+     * - Success events: Routes based on priority (handler result -> redirectto -> source)
+     * - Error events: Always routes back to the source
      *
-     * **Routing**
+     * Telemetry Integration:
+     * - Creates and manages OpenTelemetry spans for execution tracking
+     * - Propagates trace context through the event chain
+     * - Records execution metrics and error details
      *
-     * The routing of the resulting events is determined as follows:
-     * - The `to` field of the output event is set in this priority:
-     *   1. The `to` field provided by the handler result
-     *   2. The `redirectto` field from the input event
-     *   3. The `source` field from the input event (as a form of reply)
-     * - For system error events, the `to` field is always set to the `source` of the input event.
+     * Version Resolution:
+     * - Extracts version from event dataschema
+     * - Falls back to latest version if unspecified
+     * - Validates event data against versioned contract schema
      *
-     * **Telemetry**
+     * Error Handling:
+     * - Converts all errors to system error events
+     * - Maintains telemetry context for error scenarios
+     * - Ensures proper error event routing
      *
-     * - Creates a new span for each execution as per the traceparent and tracestate field
-     *   of the event. If those are not present, then a brand new span is created and distributed
-     *   tracing is disabled
-     * - Sets span attributes for input and output events
-     * - Propagates trace context to output events
-     * - Handles error cases and sets appropriate span status
+     * @param event - The event to process
+     * @param opentelemetry - Configuration for OpenTelemetry context inheritance
+     * @returns Promise resolving to array of result events or error event
      */
-    ArvoEventHandler.prototype.execute = function (event, opentelemetry) {
-        return __awaiter(this, void 0, void 0, function () {
-            var span;
+    ArvoEventHandler.prototype.execute = function (event_1) {
+        return __awaiter(this, arguments, void 0, function (event, opentelemetry) {
             var _this = this;
+            if (opentelemetry === void 0) { opentelemetry = {
+                inheritFrom: 'EVENT',
+            }; }
             return __generator(this, function (_a) {
                 switch (_a.label) {
-                    case 0:
-                        span = (0, utils_2.createOtelSpan)({
-                            spanName: "ArvoEventHandler<".concat(this.contract.uri, ">.execute<").concat(event.type, ">"),
-                            spanKinds: {
-                                kind: this.openTelemetrySpanKind,
-                                openInference: this.openInferenceSpanKind,
-                                arvoExecution: this.arvoExecutionSpanKind,
-                            },
-                            event: event,
-                            opentelemetryConfig: opentelemetry,
-                        });
-                        return [4 /*yield*/, api_1.context.with(api_1.trace.setSpan(api_1.context.active(), span), function () { return __awaiter(_this, void 0, void 0, function () {
-                                var otelSpanHeaders, parsedDataSchema, handlerContract, inputEventValidation, _handleOutput, outputs, eventFactory_1, error_1, eventFactory, result;
-                                var _a, _b, _c, _d, _e;
-                                return __generator(this, function (_f) {
-                                    switch (_f.label) {
+                    case 0: return [4 /*yield*/, arvo_core_1.ArvoOpenTelemetry.getInstance().startActiveSpan({
+                            name: 'ArvoEventHandler',
+                            spanOptions: this.spanOptions,
+                            disableSpanManagement: true,
+                            context: opentelemetry.inheritFrom === 'EVENT'
+                                ? {
+                                    inheritFrom: 'TRACE_HEADERS',
+                                    traceHeaders: {
+                                        traceparent: event.traceparent,
+                                        tracestate: event.tracestate,
+                                    },
+                                }
+                                : {
+                                    inheritFrom: 'CONTEXT',
+                                    context: api_1.context.active(),
+                                },
+                            fn: function (span) { return __awaiter(_this, void 0, void 0, function () {
+                                var otelSpanHeaders, parsedDataSchema, handlerContract, inputEventValidation, _handleOutput, outputs, eventFactory_1, result, error_1, eventFactory, result;
+                                var _a, _b, _c, _d;
+                                return __generator(this, function (_e) {
+                                    switch (_e.label) {
                                         case 0:
                                             otelSpanHeaders = (0, arvo_core_1.currentOpenTelemetryHeaders)();
-                                            _f.label = 1;
+                                            _e.label = 1;
                                         case 1:
-                                            _f.trys.push([1, 3, 4, 5]);
+                                            _e.trys.push([1, 3, 4, 5]);
                                             span.setStatus({ code: api_1.SpanStatusCode.OK });
+                                            Object.entries(event.otelAttributes).forEach(function (_a) {
+                                                var key = _a[0], value = _a[1];
+                                                return span.setAttribute("to_process.0.".concat(key), value);
+                                            });
                                             if (this.contract.type !== event.type) {
-                                                throw new Error("Invalid event type='".concat(event.type, "' is provide to handler for type='").concat(this.contract.type, "'"));
+                                                throw new Error("Event type mismatch: Received '".concat(event.type, "', expected '").concat(this.contract.type, "'"));
                                             }
-                                            parsedDataSchema = (0, arvo_core_1.parseEventDataSchema)(event);
+                                            (0, arvo_core_1.logToSpan)({
+                                                level: 'INFO',
+                                                message: "Event type '".concat(event.type, "' validated against contract '").concat(this.contract.uri, "'"),
+                                            });
+                                            parsedDataSchema = arvo_core_1.EventDataschemaUtil.parse(event);
                                             if (!(parsedDataSchema === null || parsedDataSchema === void 0 ? void 0 : parsedDataSchema.version)) {
                                                 (0, arvo_core_1.logToSpan)({
                                                     level: 'WARNING',
-                                                    message: "Unable to resolve the event version from dataschema \"".concat(event.dataschema, "\". Defaulting to the latest version."),
+                                                    message: "Version resolution failed for event with dataschema '".concat(event.dataschema, "'. Defaulting to latest version (=").concat(this.contract.version('latest').version, ") of contract (uri=").concat(this.contract.uri, ")"),
                                                 });
                                             }
                                             handlerContract = this.contract.version((_a = parsedDataSchema === null || parsedDataSchema === void 0 ? void 0 : parsedDataSchema.version) !== null && _a !== void 0 ? _a : 'latest');
-                                            Object.entries(event.otelAttributes).forEach(function (_a) {
-                                                var key = _a[0], value = _a[1];
-                                                return span.setAttribute("to_process.0.".concat(key), value);
+                                            (0, arvo_core_1.logToSpan)({
+                                                level: 'INFO',
+                                                message: "Processing event with contract version ".concat(handlerContract.version),
                                             });
                                             inputEventValidation = handlerContract.accepts.schema.safeParse(event.data);
                                             if (inputEventValidation.error) {
-                                                throw new Error("Invalid event payload: ".concat(inputEventValidation.error));
+                                                throw new Error("Event payload validation failed: ".concat(inputEventValidation.error));
                                             }
-                                            return [4 /*yield*/, this._handler[handlerContract.version]({
+                                            (0, arvo_core_1.logToSpan)({
+                                                level: 'INFO',
+                                                message: "Event payload validated successfully against contract ".concat(arvo_core_1.EventDataschemaUtil.create(handlerContract)),
+                                            });
+                                            (0, arvo_core_1.logToSpan)({
+                                                level: 'INFO',
+                                                message: "Executing handler for event type '".concat(event.type, "'"),
+                                            });
+                                            return [4 /*yield*/, this.handler[handlerContract.version]({
                                                     event: event,
                                                     source: this.source,
+                                                    span: span,
                                                 })];
                                         case 2:
-                                            _handleOutput = _f.sent();
+                                            _handleOutput = _e.sent();
                                             if (!_handleOutput)
                                                 return [2 /*return*/, []];
                                             outputs = [];
@@ -227,19 +229,23 @@ var ArvoEventHandler = /** @class */ (function (_super) {
                                                 outputs = [_handleOutput];
                                             }
                                             eventFactory_1 = (0, arvo_core_1.createArvoEventFactory)(handlerContract);
-                                            return [2 /*return*/, (0, utils_1.eventHandlerOutputEventCreator)(outputs, otelSpanHeaders, this.source, event, this.executionunits, function (param, extension) {
-                                                    var _a;
-                                                    return eventFactory_1.emits(param, extension, {
-                                                        tracer: (_a = opentelemetry === null || opentelemetry === void 0 ? void 0 : opentelemetry.tracer) !== null && _a !== void 0 ? _a : (0, OpenTelemetry_1.fetchOpenTelemetryTracer)(),
-                                                    });
-                                                })];
+                                            result = (0, utils_1.eventHandlerOutputEventCreator)(outputs, otelSpanHeaders, this.source, event, this.executionunits, function (param, extensions) { return eventFactory_1.emits(param, extensions); });
+                                            (0, arvo_core_1.logToSpan)({
+                                                level: 'INFO',
+                                                message: "Event processing completed successfully. Generated ".concat(result.length, " event(s)"),
+                                            });
+                                            (0, arvo_core_1.logToSpan)({
+                                                level: 'INFO',
+                                                message: 'Event handled successfully',
+                                            });
+                                            return [2 /*return*/, result];
                                         case 3:
-                                            error_1 = _f.sent();
-                                            eventFactory = (0, arvo_core_1.createArvoEventFactory)(this.contract.version('any'));
+                                            error_1 = _e.sent();
+                                            eventFactory = (0, arvo_core_1.createArvoEventFactory)(this.contract.version('latest'));
                                             (0, arvo_core_1.exceptionToSpan)(error_1);
                                             span.setStatus({
                                                 code: api_1.SpanStatusCode.ERROR,
-                                                message: error_1.message,
+                                                message: "Event processing failed: ".concat(error_1.message),
                                             });
                                             result = eventFactory.systemError({
                                                 source: this.source,
@@ -252,7 +258,7 @@ var ArvoEventHandler = /** @class */ (function (_super) {
                                                 traceparent: (_b = otelSpanHeaders.traceparent) !== null && _b !== void 0 ? _b : undefined,
                                                 tracestate: (_c = otelSpanHeaders.tracestate) !== null && _c !== void 0 ? _c : undefined,
                                                 accesscontrol: (_d = event.accesscontrol) !== null && _d !== void 0 ? _d : undefined,
-                                            }, {}, { tracer: (_e = opentelemetry === null || opentelemetry === void 0 ? void 0 : opentelemetry.tracer) !== null && _e !== void 0 ? _e : (0, OpenTelemetry_1.fetchOpenTelemetryTracer)() });
+                                            }, {});
                                             Object.entries(result.otelAttributes).forEach(function (_a) {
                                                 var key = _a[0], value = _a[1];
                                                 return span.setAttribute("to_emit.0.".concat(key), value);
@@ -264,7 +270,8 @@ var ArvoEventHandler = /** @class */ (function (_super) {
                                         case 5: return [2 /*return*/];
                                     }
                                 });
-                            }); })];
+                            }); },
+                        })];
                     case 1: return [2 /*return*/, _a.sent()];
                 }
             });
@@ -272,19 +279,12 @@ var ArvoEventHandler = /** @class */ (function (_super) {
     };
     Object.defineProperty(ArvoEventHandler.prototype, "systemErrorSchema", {
         /**
-         * Provides the schema for system error events.
-         *
-         * @returns An object containing the error event type and schema.
-         *
-         * @remarks
-         * This getter defines the structure for system error events that may be emitted
-         * when an unexpected error occurs during event handling. The error event type
-         * is prefixed with 'sys.' followed by the contract's accepted event type and '.error'.
-         * The schema used for these error events is the standard ArvoErrorSchema.
+         * Provides access to the system error event schema configuration.
+         * The schema defines the structure of error events emitted during execution failures.
          *
-         * @example
-         * // If the contract's accepted event type is 'user.created'
-         * // The system error event type would be 'sys.user.created.error'
+         * Error events follow the naming convention: sys.<contract-type>.error
+         * For example, a contract handling 'user.created' events will emit error events
+         * with the type 'sys.user.created.error'.
          */
         get: function () {
             return this.contract.systemError;

package/dist/ArvoEventHandler/types.d.ts

@@ -1,22 +1,22 @@
-import { SpanKind } from '@opentelemetry/api';
-import { ArvoContract, ArvoEvent, CreateArvoEvent, OpenInferenceSpanKind, ArvoExecutionSpanKind, VersionedArvoContract, ArvoSemanticVersion } from 'arvo-core';
+import { Span, SpanOptions } from '@opentelemetry/api';
+import { ArvoContract, ArvoEvent, CreateArvoEvent, VersionedArvoContract, ArvoSemanticVersion } from 'arvo-core';
 import { z } from 'zod';
 /**
  * Represents the input for an ArvoEvent handler function.
- * @template TAccepts - The type of ArvoContractRecord that the handler accepts.
  */
-export type ArvoEventHandlerFunctionInput<TContract extends VersionedArvoContract<ArvoContract, ArvoSemanticVersion>> = {
+export type ArvoEventHandlerFunctionInput<TContract extends VersionedArvoContract<any, any>> = {
     /** The ArvoEvent object. */
     event: ArvoEvent<z.infer<TContract['accepts']['schema']>, Record<string, any>, TContract['accepts']['type']>;
     /** The source field data of the handler */
     source: string;
+    /** The OpenTelemetry span */
+    span: Span;
 };
 /**
  * Represents the output of an ArvoEvent handler function.
- * @template TContract - The type of ArvoContract that the handler is associated with.
  */
-export type ArvoEventHandlerFunctionOutput<TContract extends VersionedArvoContract<ArvoContract, ArvoSemanticVersion>> = {
-    [K in keyof TContract['emits']]: Omit<CreateArvoEvent<z.infer<TContract['emits'][K]>, K & string>, 'subject' | 'source' | 'executionunits' | 'traceparent' | 'tracestate'> & {
+export type ArvoEventHandlerFunctionOutput<TContract extends VersionedArvoContract<any, any>> = {
+    [K in keyof TContract['emits']]: Pick<CreateArvoEvent<z.infer<TContract['emits'][K]>, K & string>, 'id' | 'time' | 'type' | 'data' | 'to' | 'accesscontrol' | 'redirectto'> & {
         /**
          * An optional override for the execution units of this specific event.
          *
@@ -31,29 +31,14 @@ export type ArvoEventHandlerFunctionOutput<TContract extends VersionedArvoContra
 }[keyof TContract['emits']];
 /**
  * Defines the structure of an ArvoEvent handler function.
- * @template TContract - The type of ArvoContract that the handler is associated with.
  */
 export type ArvoEventHandlerFunction<TContract extends ArvoContract> = {
     [V in ArvoSemanticVersion & keyof TContract['versions']]: (params: ArvoEventHandlerFunctionInput<VersionedArvoContract<TContract, V>>) => Promise<Array<ArvoEventHandlerFunctionOutput<VersionedArvoContract<TContract, V>>> | ArvoEventHandlerFunctionOutput<VersionedArvoContract<TContract, V>> | void>;
 };
 /**
  * Interface for an ArvoEvent handler.
- * @template T - The type of the contract (defaults to string).
- * @template TAccepts - The type of ArvoContractRecord that the handler accepts.
- * @template TEmits - The type of ArvoContractRecord that the handler emits.
  */
 export interface IArvoEventHandler<TContract extends ArvoContract> {
-    /**
-     * An override source for emitted events.
-     * @remarks
-     * When provided, this value will be used as the source for emitted events
-     * instead of the `contract.accepts.type`. Use this very carefully as it may
-     * reduce system transparency and make event tracking more difficult.
-     *
-     * It's recommended to rely on the default source (`contract.accepts.type`)
-     * whenever possible to maintain consistent and traceable event chains.
-     */
-    source?: string;
     /**
      * The contract for the handler defining its input and outputs as well as the description.
      */
@@ -70,15 +55,7 @@ export interface IArvoEventHandler<TContract extends ArvoContract> {
      */
     handler: ArvoEventHandlerFunction<TContract>;
     /**
-     * The OpenTelemetry span kind attributes for the handler
-     * executor.
-     * @param [openInference] - The OpenInference span kind. Default is "CHAIN"
-     * @param [arvoExecution] - The ArvoExecution span kind. Default is "EVENT_HANDLER"
-     * @param [openTelemetry] - The OpenTelemetry span kind. Default is "INTERNAL"
+     * The OpenTelemetry span options
      */
-    spanKind?: {
-        openInference?: OpenInferenceSpanKind;
-        arvoExecution?: ArvoExecutionSpanKind;
-        openTelemetry?: SpanKind;
-    };
+    spanOptions?: SpanOptions;
 }

package/dist/ArvoEventRouter/helpers.d.ts

@@ -1,36 +1,19 @@
 import { ArvoEventRouter } from '.';
 import { IArvoEventRouter } from './types';
 /**
- * Creates and returns a new instance of ArvoEventRouter.
+ * Creates a new ArvoEventRouter instance with the provided configuration.
+ * Validates source format and ensures unique handlers per event type.
  *
- * @param {IArvoEventRouter} param - Configuration object for the ArvoEventRouter.
- * @returns {ArvoEventRouter} A new instance of ArvoEventRouter.
- *
- * @throws {Error} If there are duplicate handlers for the same event type.
- * @throws {Error} If the provided source is an invalid string.
+ * @param param Configuration for router initialization including source,
+ * handlers, and execution metrics
+ * @returns Configured ArvoEventRouter instance
+ * @throws When handlers have duplicate event types or source format is invalid
  *
  * @example
  * const router = createArvoEventRouter({
- *   source: 'my-router',
- *   handlers: [handler1, handler2],
+ *   source: 'payment.service',
+ *   handlers: [paymentHandler, notificationHandler],
  *   executionunits: 10
  * });
- *
- * @remarks
- * This function is a factory method that simplifies the creation of an ArvoEventRouter instance.
- * It encapsulates the instantiation process, allowing for a more concise and readable way to create routers.
- *
- * The `IArvoEventRouter` parameter should include:
- * - `source`: (optional) A string identifying the source of the router. Used to match the `event.to` field.
- * - `handlers`: An array of ArvoEventHandler instances that the router will use to process events.
- * - `executionunits`: A number representing the default execution cost of the function.
- *
- * The created ArvoEventRouter will:
- * - Validate the source string if provided.
- * - Check for and prevent duplicate handlers for the same event type.
- * - Set up internal data structures for efficient event routing.
- *
- * @see {@link ArvoEventRouter} for more details on the router's functionality.
- * @see {@link IArvoEventRouter} for the structure of the configuration object.
  */
 export declare const createArvoEventRouter: (param: IArvoEventRouter) => ArvoEventRouter;

package/dist/ArvoEventRouter/helpers.js

@@ -3,37 +3,20 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.createArvoEventRouter = void 0;
 var _1 = require(".");
 /**
- * Creates and returns a new instance of ArvoEventRouter.
+ * Creates a new ArvoEventRouter instance with the provided configuration.
+ * Validates source format and ensures unique handlers per event type.
  *
- * @param {IArvoEventRouter} param - Configuration object for the ArvoEventRouter.
- * @returns {ArvoEventRouter} A new instance of ArvoEventRouter.
- *
- * @throws {Error} If there are duplicate handlers for the same event type.
- * @throws {Error} If the provided source is an invalid string.
+ * @param param Configuration for router initialization including source,
+ * handlers, and execution metrics
+ * @returns Configured ArvoEventRouter instance
+ * @throws When handlers have duplicate event types or source format is invalid
  *
  * @example
  * const router = createArvoEventRouter({
- *   source: 'my-router',
- *   handlers: [handler1, handler2],
+ *   source: 'payment.service',
+ *   handlers: [paymentHandler, notificationHandler],
  *   executionunits: 10
  * });
- *
- * @remarks
- * This function is a factory method that simplifies the creation of an ArvoEventRouter instance.
- * It encapsulates the instantiation process, allowing for a more concise and readable way to create routers.
- *
- * The `IArvoEventRouter` parameter should include:
- * - `source`: (optional) A string identifying the source of the router. Used to match the `event.to` field.
- * - `handlers`: An array of ArvoEventHandler instances that the router will use to process events.
- * - `executionunits`: A number representing the default execution cost of the function.
- *
- * The created ArvoEventRouter will:
- * - Validate the source string if provided.
- * - Check for and prevent duplicate handlers for the same event type.
- * - Set up internal data structures for efficient event routing.
- *
- * @see {@link ArvoEventRouter} for more details on the router's functionality.
- * @see {@link IArvoEventRouter} for the structure of the configuration object.
  */
 var createArvoEventRouter = function (param) {
     return new _1.ArvoEventRouter(param);