arvo-event-handler 0.0.1

package/CHANGELOG.md

@@ -0,0 +1,5 @@
+# Changelog
+
+## [0.0.1] - 2024-09-07
+
+- Finalised version 0.0.1 of the event handlers for Arvo

package/LICENSE.md

@@ -0,0 +1,7 @@
+The MIT License (MIT)
+Copyright (c) 2024 Saad Ahmad
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/README.md

@@ -0,0 +1,43 @@
+# Arvo
+
+## What is Arvo
+
+Arvo is an opinionated approach to building event-driven systems. It's designed as a pattern and methodology rather than a rigid framework.
+
+## Principal
+
+The core principle of Arvo is to provide a solid foundation with enough flexibility for customization, allowing you to impose your own technical posture, including security measures, event brokerage, and telemetry. While Arvo offers a structured approach, it encourages developers to implement their own solutions if they believe they can improve upon or diverge from Arvo's principles.
+
+If you're looking to focus on results without getting bogged down in the nitty-gritty of event creation, handling, system state management, and telemetry, while also avoiding vendor lock-in, Arvo provides an excellent starting point. I believe, it strikes a balance between opinionated design and customization, making it an ideal choice for developers who want a head start in building event-driven systems without sacrificing flexibility.
+
+Key features of Arvo include:
+
+- Lightweight and unopinionated core
+- Extensible architecture
+- Cloud-agnostic design
+- Built-in primitives for event-driven patterns
+- Easy integration with existing systems and tools
+
+Whether you're building a small microservice or a large-scale distributed system, my hope with Arvo is to offers you some of the tools and patterns to help you succeed in the world of event-driven architecture.
+
+# Arvo - Event Handler
+
+## Installation
+
+You can install the core package via `npm` or `yarn`
+
+```bash
+npm install arvo-event-handler
+```
+
+```bash
+yarn add arvo-event-handler
+```
+
+## License
+
+This package is available under the MIT License. For more details, refer to the [LICENSE.md](LICENSE.md) file in the project repository.
+
+## Change Logs
+
+For a detailed list of changes and updates, please refer to the [document](CHANGELOG.md) file.

package/dist/ArvoEventHandler/helpers.d.ts

@@ -0,0 +1,31 @@
+import { ArvoContract } from 'arvo-core';
+import { IArvoEventHandler } from './types';
+import ArvoEventHandler from '.';
+/**
+ * Creates an ArvoEventHandler instance for a given ArvoContract.
+ *
+ * @template TContract - The type of ArvoContract this handler is associated with.
+ * @param param - The configuration parameters for the event handler.
+ * @returns A new instance of ArvoEventHandler<TContract>.
+ *
+ * @remarks
+ * This function is a factory for creating ArvoEventHandler instances.
+ * It encapsulates the creation process and provides a convenient way to instantiate
+ * handlers for specific Arvo contracts.
+ *
+ * @example
+ * ```typescript
+ * const myContract = new ArvoContract(...);
+ * const myHandler = createArvoEventHandler({
+ *   contract: myContract,
+ *   executionunits: 100,
+ *   handler: async ({ event }) => {
+ *     // Handler implementation
+ *   }
+ * });
+ * ```
+ *
+ * @see {@link IArvoEventHandler} for the full configuration options
+ * @see {@link ArvoEventHandler} for the handler class implementation
+ */
+export declare const createArvoEventHandler: <TContract extends ArvoContract>(param: IArvoEventHandler<TContract>) => ArvoEventHandler<TContract>;

package/dist/ArvoEventHandler/helpers.js

@@ -0,0 +1,36 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createArvoEventHandler = void 0;
+var _1 = __importDefault(require("."));
+/**
+ * Creates an ArvoEventHandler instance for a given ArvoContract.
+ *
+ * @template TContract - The type of ArvoContract this handler is associated with.
+ * @param param - The configuration parameters for the event handler.
+ * @returns A new instance of ArvoEventHandler<TContract>.
+ *
+ * @remarks
+ * This function is a factory for creating ArvoEventHandler instances.
+ * It encapsulates the creation process and provides a convenient way to instantiate
+ * handlers for specific Arvo contracts.
+ *
+ * @example
+ * ```typescript
+ * const myContract = new ArvoContract(...);
+ * const myHandler = createArvoEventHandler({
+ *   contract: myContract,
+ *   executionunits: 100,
+ *   handler: async ({ event }) => {
+ *     // Handler implementation
+ *   }
+ * });
+ * ```
+ *
+ * @see {@link IArvoEventHandler} for the full configuration options
+ * @see {@link ArvoEventHandler} for the handler class implementation
+ */
+var createArvoEventHandler = function (param) { return new _1.default(param); };
+exports.createArvoEventHandler = createArvoEventHandler;

package/dist/ArvoEventHandler/index.d.ts

@@ -0,0 +1,91 @@
+import { ArvoContract, ArvoEvent, ArvoExecutionSpanKind, OpenInferenceSpanKind, ResolveArvoContractRecord } from 'arvo-core';
+import { IArvoEventHandler } from './types';
+import { SpanKind } from '@opentelemetry/api';
+/**
+ * Represents an event handler for Arvo contracts.
+ *
+ * @template TContract - The type of ArvoContract this handler is associated with.
+ *
+ * @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.
+ */
+export default class ArvoEventHandler<TContract extends ArvoContract> {
+    /** The contract of the handler to which it is bound */
+    readonly contract: TContract;
+    /** The default execution cost associated with this handler */
+    readonly executionunits: number;
+    /**
+     * The source identifier for events produced by this handler
+     *
+     * @remarks
+     * For all the events which are emitted by the handler, this is
+     * the source field value of them all.
+    */
+    readonly source: string;
+    readonly openInferenceSpanKind: OpenInferenceSpanKind;
+    readonly arvoExecutionSpanKind: ArvoExecutionSpanKind;
+    readonly openTelemetrySpanKind: SpanKind;
+    private readonly _handler;
+    /**
+     * Creates an instance of ArvoEventHandler.
+     *
+     * @param param - The configuration parameters for the event handler.
+     *
+     * @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.
+     */
+    constructor(param: IArvoEventHandler<TContract>);
+    /**
+     * Executes the event handler for a given event.
+     *
+     * @param event - The event to handle.
+     * @returns A promise that resolves to the resulting ArvoEvent.
+     *
+     * @remarks
+     * 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.
+     * 5. Handles any errors and creates an error event if necessary.
+     *
+     * All telemetry data is properly set and propagated throughout the execution.
+     */
+    execute(event: ArvoEvent<ResolveArvoContractRecord<TContract['accepts']>, Record<string, any>, TContract['accepts']['type']>): Promise<ArvoEvent | null>;
+    /**
+     * 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.
+     *
+     * @example
+     * // If the contract's accepted event type is 'user.created'
+     * // The system error event type would be 'sys.user.created.error'
+     */
+    get systemErrorSchema(): {
+        type: string;
+        schema: import("zod").ZodObject<{
+            errorName: import("zod").ZodString;
+            errorMessage: import("zod").ZodString;
+            errorStack: import("zod").ZodNullable<import("zod").ZodString>;
+        }, "strip", import("zod").ZodTypeAny, {
+            errorName: string;
+            errorMessage: string;
+            errorStack: string | null;
+        }, {
+            errorName: string;
+            errorMessage: string;
+            errorStack: string | null;
+        }>;
+    };
+}

package/dist/ArvoEventHandler/index.js

@@ -0,0 +1,239 @@
+"use strict";
+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) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var arvo_core_1 = require("arvo-core");
+var schema_1 = require("arvo-core/dist/ArvoEvent/schema");
+var OpenTelemetry_1 = require("../OpenTelemetry");
+var api_1 = require("@opentelemetry/api");
+/**
+ * Represents an event handler for Arvo contracts.
+ *
+ * @template TContract - The type of ArvoContract this handler is associated with.
+ *
+ * @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.
+ */
+var ArvoEventHandler = /** @class */ (function () {
+    /**
+     * Creates an instance of ArvoEventHandler.
+     *
+     * @param param - The configuration parameters for the event handler.
+     *
+     * @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.
+     */
+    function ArvoEventHandler(param) {
+        var _a, _b, _c;
+        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 = param.source || this.contract.accepts.type;
+        this.arvoExecutionSpanKind = ((_a = param.spanKind) === null || _a === void 0 ? void 0 : _a.arvoExecution) || this.arvoExecutionSpanKind;
+        this.openInferenceSpanKind = ((_b = param.spanKind) === null || _b === void 0 ? void 0 : _b.openInference) || this.openInferenceSpanKind;
+        this.openTelemetrySpanKind = ((_c = param.spanKind) === null || _c === void 0 ? void 0 : _c.openTelemetry) || this.openTelemetrySpanKind;
+    }
+    /**
+     * Executes the event handler for a given event.
+     *
+     * @param event - The event to handle.
+     * @returns A promise that resolves to the resulting ArvoEvent.
+     *
+     * @remarks
+     * 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.
+     * 5. Handles any errors and creates an error event if necessary.
+     *
+     * All telemetry data is properly set and propagated throughout the execution.
+     */
+    ArvoEventHandler.prototype.execute = function (event) {
+        return __awaiter(this, void 0, void 0, function () {
+            var spanName, spanOptions, span, inheritedContext, eventFactory;
+            var _a;
+            var _this = this;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        spanName = "ArvoEventHandler<".concat(this.contract.uri, ">.execute<").concat(event.type, ">");
+                        spanOptions = {
+                            kind: this.openTelemetrySpanKind,
+                            attributes: (_a = {},
+                                _a[arvo_core_1.OpenInference.ATTR_SPAN_KIND] = this.openInferenceSpanKind,
+                                _a[arvo_core_1.ArvoExecution.ATTR_SPAN_KIND] = this.arvoExecutionSpanKind,
+                                _a)
+                        };
+                        if (event.traceparent) {
+                            inheritedContext = (0, OpenTelemetry_1.extractContext)(event.traceparent, event.tracestate);
+                            span = OpenTelemetry_1.ArvoEventHandlerTracer.startSpan(spanName, spanOptions, inheritedContext);
+                        }
+                        else {
+                            span = OpenTelemetry_1.ArvoEventHandlerTracer.startSpan(spanName, spanOptions);
+                        }
+                        eventFactory = (0, arvo_core_1.createArvoEventFactory)(this.contract);
+                        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, inputEventValidation, output, __extensions, handlerResult, result, error_1, result;
+                                return __generator(this, function (_a) {
+                                    switch (_a.label) {
+                                        case 0:
+                                            otelSpanHeaders = (0, arvo_core_1.currentOpenTelemetryHeaders)();
+                                            _a.label = 1;
+                                        case 1:
+                                            _a.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.".concat(key), value);
+                                            });
+                                            inputEventValidation = this.contract.validateInput(event.type, event.data);
+                                            if (inputEventValidation.error) {
+                                                throw new Error("Invalid event payload: ".concat(inputEventValidation.error));
+                                            }
+                                            return [4 /*yield*/, this._handler({ event: event })];
+                                        case 2:
+                                            output = _a.sent();
+                                            if (!output)
+                                                return [2 /*return*/, null];
+                                            __extensions = output.__extensions, handlerResult = __rest(output, ["__extensions"]);
+                                            result = eventFactory.emits(__assign(__assign({}, handlerResult), { traceparent: otelSpanHeaders.traceparent || undefined, tracestate: otelSpanHeaders.tracestate || undefined, source: this.source, subject: event.subject, to: handlerResult.to || event.source, executionunits: handlerResult.executionunits || this.executionunits }), __extensions);
+                                            span.setAttributes(result.otelAttributes);
+                                            Object.entries(result.otelAttributes).forEach(function (_a) {
+                                                var key = _a[0], value = _a[1];
+                                                return span.setAttribute("to_emit.".concat(key), value);
+                                            });
+                                            return [2 /*return*/, result];
+                                        case 3:
+                                            error_1 = _a.sent();
+                                            (0, arvo_core_1.exceptionToSpan)(error_1);
+                                            span.setStatus({
+                                                code: api_1.SpanStatusCode.ERROR,
+                                                message: error_1.message,
+                                            });
+                                            result = eventFactory.systemError({
+                                                source: this.source,
+                                                subject: event.subject,
+                                                to: event.source,
+                                                error: error_1,
+                                                executionunits: this.executionunits,
+                                                traceparent: otelSpanHeaders.traceparent || undefined,
+                                                tracestate: otelSpanHeaders.tracestate || undefined,
+                                            }, {});
+                                            Object.entries(result.otelAttributes).forEach(function (_a) {
+                                                var key = _a[0], value = _a[1];
+                                                return span.setAttribute("to_emit.".concat(key), value);
+                                            });
+                                            return [2 /*return*/, result];
+                                        case 4:
+                                            span.end();
+                                            return [7 /*endfinally*/];
+                                        case 5: return [2 /*return*/];
+                                    }
+                                });
+                            }); })];
+                    case 1: return [2 /*return*/, _b.sent()];
+                }
+            });
+        });
+    };
+    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.
+         *
+         * @example
+         * // If the contract's accepted event type is 'user.created'
+         * // The system error event type would be 'sys.user.created.error'
+         */
+        get: function () {
+            return {
+                type: "sys.".concat(this.contract.accepts.type, ".error"),
+                schema: arvo_core_1.ArvoErrorSchema
+            };
+        },
+        enumerable: false,
+        configurable: true
+    });
+    return ArvoEventHandler;
+}());
+exports.default = ArvoEventHandler;

package/dist/ArvoEventHandler/types.d.ts

@@ -0,0 +1,81 @@
+import { SpanKind } from '@opentelemetry/api';
+import { ArvoContract, ArvoEvent, ResolveArvoContractRecord, CreateArvoEvent, OpenInferenceSpanKind, ArvoExecutionSpanKind } 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 ArvoContract> = {
+    /** The ArvoEvent object. */
+    event: ArvoEvent<ResolveArvoContractRecord<TContract['accepts']>, Record<string, any>, TContract['accepts']['type']>;
+};
+/**
+ * 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 ArvoContract> = {
+    [K in keyof TContract['emits']]: Omit<CreateArvoEvent<z.infer<TContract['emits'][K]>, K & string>, 'subject' | 'source' | 'executionunits' | 'traceparent' | 'tracestate'> & {
+        /**
+         * An optional override for the execution units of this specific event.
+         *
+         * @remarks
+         * Execution units represent the computational cost or resources required to process this event.
+         * If not provided, the default value defined in the handler's constructor will be used.
+         */
+        executionunits?: number;
+        /** Optional extensions for the event. */
+        __extensions?: Record<string, string | number | boolean>;
+    };
+}[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> = (params: ArvoEventHandlerFunctionInput<TContract>) => Promise<ArvoEventHandlerFunctionOutput<TContract> | 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.
+     * @deprecated This field is deprecated and should be used with caution.
+     * @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.
+     */
+    contract: TContract;
+    /**
+     * The default execution cost of the function.
+     * This can represent a dollar value or some other number with a rate card.
+     */
+    executionunits: number;
+    /**
+     * The functional handler of the event which takes the input, performs an action, and returns the result.
+     * @param params - The input parameters for the handler function.
+     * @returns A promise of object containing the created ArvoEvent and optional extensions.
+     */
+    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"
+     */
+    spanKind?: {
+        openInference?: OpenInferenceSpanKind;
+        arvoExecution?: ArvoExecutionSpanKind;
+        openTelemetry?: SpanKind;
+    };
+}

package/dist/ArvoEventHandler/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/MultiArvoEventHandler/helpers.d.ts

@@ -0,0 +1,48 @@
+import MultiArvoEventHandler from '.';
+import { IMultiArvoEventHandler } from './types';
+/**
+ * Creates a MultiArvoEventHandler instance capable of handling multiple event types across different ArvoContracts.
+ *
+ * @param param - The configuration parameters for the event handler.
+ * @returns A new instance of MultiArvoEventHandler.
+ *
+ * @remarks
+ * This factory function instantiates a MultiArvoEventHandler, which is designed to process
+ * multiple event types from various ArvoContracts. Unlike the more specialized ArvoEventHandler,
+ * MultiArvoEventHandler offers greater flexibility by not being bound to a specific contract
+ * or event type.
+ *
+ * Key features of MultiArvoEventHandler:
+ * - Handles multiple event types
+ * - Works across different ArvoContracts
+ * - Provides a unified interface for diverse event processing
+ *
+ * The handler's behavior and resource allocation are determined by the provided configuration
+ * parameters, including execution units and the event processing logic.
+ *
+ * @example
+ * ```typescript
+ * const multiEventHandler = createMultiArvoEventHandler({
+ *   source: 'com.multi.handler',
+ *   executionunits: 100,
+ *   handler: async ({ event }) => {
+ *     switch(event.type) {
+ *       case 'com.user.registered':
+ *         // Handle user registration event
+ *         break;
+ *       case 'com.transaction.complete':
+ *         // Handle transaction completion event
+ *         break;
+ *       // ... handle other event types
+ *     }
+ *   }
+ * });
+ *
+ * // Use the handler
+ * await multiEventHandler.handleEvent(someEvent);
+ * ```
+ *
+ * @see {@link IMultiArvoEventHandler} for the full configuration options
+ * @see {@link MultiArvoEventHandler} for the handler class implementation
+ */
+export declare const createMultiArvoEventHandler: (param: IMultiArvoEventHandler) => MultiArvoEventHandler;

package/dist/MultiArvoEventHandler/helpers.js

@@ -0,0 +1,54 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createMultiArvoEventHandler = void 0;
+var _1 = __importDefault(require("."));
+/**
+ * Creates a MultiArvoEventHandler instance capable of handling multiple event types across different ArvoContracts.
+ *
+ * @param param - The configuration parameters for the event handler.
+ * @returns A new instance of MultiArvoEventHandler.
+ *
+ * @remarks
+ * This factory function instantiates a MultiArvoEventHandler, which is designed to process
+ * multiple event types from various ArvoContracts. Unlike the more specialized ArvoEventHandler,
+ * MultiArvoEventHandler offers greater flexibility by not being bound to a specific contract
+ * or event type.
+ *
+ * Key features of MultiArvoEventHandler:
+ * - Handles multiple event types
+ * - Works across different ArvoContracts
+ * - Provides a unified interface for diverse event processing
+ *
+ * The handler's behavior and resource allocation are determined by the provided configuration
+ * parameters, including execution units and the event processing logic.
+ *
+ * @example
+ * ```typescript
+ * const multiEventHandler = createMultiArvoEventHandler({
+ *   source: 'com.multi.handler',
+ *   executionunits: 100,
+ *   handler: async ({ event }) => {
+ *     switch(event.type) {
+ *       case 'com.user.registered':
+ *         // Handle user registration event
+ *         break;
+ *       case 'com.transaction.complete':
+ *         // Handle transaction completion event
+ *         break;
+ *       // ... handle other event types
+ *     }
+ *   }
+ * });
+ *
+ * // Use the handler
+ * await multiEventHandler.handleEvent(someEvent);
+ * ```
+ *
+ * @see {@link IMultiArvoEventHandler} for the full configuration options
+ * @see {@link MultiArvoEventHandler} for the handler class implementation
+ */
+var createMultiArvoEventHandler = function (param) { return new _1.default(param); };
+exports.createMultiArvoEventHandler = createMultiArvoEventHandler;

package/dist/MultiArvoEventHandler/index.d.ts

@@ -0,0 +1,84 @@
+import { SpanKind } from '@opentelemetry/api';
+import { ArvoEvent, ArvoExecutionSpanKind, OpenInferenceSpanKind } from "arvo-core";
+import { IMultiArvoEventHandler } from "./types";
+/**
+ * Represents a Multi ArvoEvent handler that can process multiple event types.
+ *
+ * @remarks
+ * Unlike ArvoEventHandler, which is bound to a specific ArvoContract and handles
+ * events of a single type, MultiArvoEventHandler can handle multiple event types
+ * without being tied to a specific contract. This makes it more flexible for
+ * scenarios where you need to process various event types with a single handler.
+ */
+export default class MultiArvoEventHandler {
+    /** The default execution cost associated with this handler */
+    readonly executionunits: number;
+    /**
+     * The source identifier for events produced by this handler
+     *
+     * @remarks
+     * For all the events which are emitted by the handler, this is
+     * the source field value of them all.
+    */
+    readonly source: string;
+    readonly openInferenceSpanKind: OpenInferenceSpanKind;
+    readonly arvoExecutionSpanKind: ArvoExecutionSpanKind;
+    readonly openTelemetrySpanKind: SpanKind;
+    private readonly _handler;
+    /**
+     * Creates an instance of MultiArvoEventHandler.
+     *
+     * @param param - The configuration parameters for the event handler.
+     * @throws {Error} Throws an error if the provided source is invalid.
+     */
+    constructor(param: IMultiArvoEventHandler);
+    /**
+     * Executes the event handler for a given event.
+     *
+     * @param event - The event to handle.
+     * @returns A promise that resolves to the resulting ArvoEvent.
+     *
+     * @remarks
+     * This method performs the following steps:
+     * 1. Creates an OpenTelemetry span for the execution.
+     * 2. Executes the handler function.
+     * 3. Creates and returns the result event.
+     * 4. Handles any errors and creates an error event if necessary.
+     *
+     * All telemetry data is properly set and propagated throughout the execution.
+     * The method ensures that the resulting event has the correct source, subject,
+     * and execution units, and includes any necessary tracing information.
+     */
+    execute(event: ArvoEvent): Promise<ArvoEvent | null>;
+    /**
+     * 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 handler's source and '.error'.
+     * The schema used for these error events is the standard ArvoErrorSchema.
+     *
+     * @example
+     * // If the handler's source is 'user.service'
+     * // The system error event type would be 'sys.user.service.error'
+     */
+    get systemErrorSchema(): {
+        type: string;
+        schema: import("zod").ZodObject<{
+            errorName: import("zod").ZodString;
+            errorMessage: import("zod").ZodString;
+            errorStack: import("zod").ZodNullable<import("zod").ZodString>;
+        }, "strip", import("zod").ZodTypeAny, {
+            errorName: string;
+            errorMessage: string;
+            errorStack: string | null;
+        }, {
+            errorName: string;
+            errorMessage: string;
+            errorStack: string | null;
+        }>;
+    };
+}

package/dist/MultiArvoEventHandler/index.js

@@ -0,0 +1,231 @@
+"use strict";
+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) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var api_1 = require("@opentelemetry/api");
+var arvo_core_1 = require("arvo-core");
+var schema_1 = require("arvo-core/dist/ArvoEvent/schema");
+var OpenTelemetry_1 = require("../OpenTelemetry");
+/**
+ * Represents a Multi ArvoEvent handler that can process multiple event types.
+ *
+ * @remarks
+ * Unlike ArvoEventHandler, which is bound to a specific ArvoContract and handles
+ * events of a single type, MultiArvoEventHandler can handle multiple event types
+ * without being tied to a specific contract. This makes it more flexible for
+ * scenarios where you need to process various event types with a single handler.
+ */
+var MultiArvoEventHandler = /** @class */ (function () {
+    /**
+     * Creates an instance of MultiArvoEventHandler.
+     *
+     * @param param - The configuration parameters for the event handler.
+     * @throws {Error} Throws an error if the provided source is invalid.
+     */
+    function MultiArvoEventHandler(param) {
+        var _a, _b, _c;
+        this.openInferenceSpanKind = arvo_core_1.OpenInferenceSpanKind.CHAIN;
+        this.arvoExecutionSpanKind = arvo_core_1.ArvoExecutionSpanKind.EVENT_HANDLER;
+        this.openTelemetrySpanKind = api_1.SpanKind.INTERNAL;
+        this.executionunits = param.executionunits;
+        this._handler = param.handler;
+        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 = param.source;
+        this.arvoExecutionSpanKind = ((_a = param.spanKind) === null || _a === void 0 ? void 0 : _a.arvoExecution) || this.arvoExecutionSpanKind;
+        this.openInferenceSpanKind = ((_b = param.spanKind) === null || _b === void 0 ? void 0 : _b.openInference) || this.openInferenceSpanKind;
+        this.openTelemetrySpanKind = ((_c = param.spanKind) === null || _c === void 0 ? void 0 : _c.openTelemetry) || this.openTelemetrySpanKind;
+    }
+    /**
+     * Executes the event handler for a given event.
+     *
+     * @param event - The event to handle.
+     * @returns A promise that resolves to the resulting ArvoEvent.
+     *
+     * @remarks
+     * This method performs the following steps:
+     * 1. Creates an OpenTelemetry span for the execution.
+     * 2. Executes the handler function.
+     * 3. Creates and returns the result event.
+     * 4. Handles any errors and creates an error event if necessary.
+     *
+     * All telemetry data is properly set and propagated throughout the execution.
+     * The method ensures that the resulting event has the correct source, subject,
+     * and execution units, and includes any necessary tracing information.
+     */
+    MultiArvoEventHandler.prototype.execute = function (event) {
+        return __awaiter(this, void 0, void 0, function () {
+            var spanName, spanOptions, span, inheritedContext;
+            var _a;
+            var _this = this;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        spanName = "MutliArvoEventHandler.source<".concat(this.source, ">.execute<").concat(event.type, ">");
+                        spanOptions = {
+                            kind: this.openTelemetrySpanKind,
+                            attributes: (_a = {},
+                                _a[arvo_core_1.OpenInference.ATTR_SPAN_KIND] = this.openInferenceSpanKind,
+                                _a[arvo_core_1.ArvoExecution.ATTR_SPAN_KIND] = this.arvoExecutionSpanKind,
+                                _a)
+                        };
+                        if (event.traceparent) {
+                            inheritedContext = (0, OpenTelemetry_1.extractContext)(event.traceparent, event.tracestate);
+                            span = OpenTelemetry_1.ArvoEventHandlerTracer.startSpan(spanName, spanOptions, inheritedContext);
+                        }
+                        else {
+                            span = OpenTelemetry_1.ArvoEventHandlerTracer.startSpan(spanName, spanOptions);
+                        }
+                        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, output, __extensions, handlerResult, result, error_1, result;
+                                return __generator(this, function (_a) {
+                                    switch (_a.label) {
+                                        case 0:
+                                            otelSpanHeaders = (0, arvo_core_1.currentOpenTelemetryHeaders)();
+                                            _a.label = 1;
+                                        case 1:
+                                            _a.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.".concat(key), value);
+                                            });
+                                            return [4 /*yield*/, this._handler({ event: event })];
+                                        case 2:
+                                            output = _a.sent();
+                                            if (!output)
+                                                return [2 /*return*/, null];
+                                            __extensions = output.__extensions, handlerResult = __rest(output, ["__extensions"]);
+                                            result = (0, arvo_core_1.createArvoEvent)(__assign(__assign({}, handlerResult), { traceparent: otelSpanHeaders.traceparent || undefined, tracestate: otelSpanHeaders.tracestate || undefined, source: this.source, subject: event.subject, to: handlerResult.to || event.source, executionunits: handlerResult.executionunits || this.executionunits }), __extensions);
+                                            span.setAttributes(result.otelAttributes);
+                                            Object.entries(result.otelAttributes).forEach(function (_a) {
+                                                var key = _a[0], value = _a[1];
+                                                return span.setAttribute("to_emit.".concat(key), value);
+                                            });
+                                            return [2 /*return*/, result];
+                                        case 3:
+                                            error_1 = _a.sent();
+                                            (0, arvo_core_1.exceptionToSpan)(error_1);
+                                            span.setStatus({
+                                                code: api_1.SpanStatusCode.ERROR,
+                                                message: error_1.message,
+                                            });
+                                            result = (0, arvo_core_1.createArvoEvent)({
+                                                type: "sys.".concat(this.source, ".error"),
+                                                source: this.source,
+                                                subject: event.subject,
+                                                to: event.source,
+                                                executionunits: this.executionunits,
+                                                traceparent: otelSpanHeaders.traceparent || undefined,
+                                                tracestate: otelSpanHeaders.tracestate || undefined,
+                                                data: {
+                                                    errorName: error_1.name,
+                                                    errorMessage: error_1.message,
+                                                    errorStack: error_1.stack || null
+                                                }
+                                            });
+                                            Object.entries(result.otelAttributes).forEach(function (_a) {
+                                                var key = _a[0], value = _a[1];
+                                                return span.setAttribute("to_emit.".concat(key), value);
+                                            });
+                                            return [2 /*return*/, result];
+                                        case 4:
+                                            span.end();
+                                            return [7 /*endfinally*/];
+                                        case 5: return [2 /*return*/];
+                                    }
+                                });
+                            }); })];
+                    case 1: return [2 /*return*/, _b.sent()];
+                }
+            });
+        });
+    };
+    Object.defineProperty(MultiArvoEventHandler.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 handler's source and '.error'.
+         * The schema used for these error events is the standard ArvoErrorSchema.
+         *
+         * @example
+         * // If the handler's source is 'user.service'
+         * // The system error event type would be 'sys.user.service.error'
+         */
+        get: function () {
+            return {
+                type: "sys.".concat(this.source, ".error"),
+                schema: arvo_core_1.ArvoErrorSchema
+            };
+        },
+        enumerable: false,
+        configurable: true
+    });
+    return MultiArvoEventHandler;
+}());
+exports.default = MultiArvoEventHandler;

package/dist/MultiArvoEventHandler/types.d.ts

@@ -0,0 +1,65 @@
+import { SpanKind } from "@opentelemetry/api";
+import { ArvoEvent, ArvoExecutionSpanKind, CreateArvoEvent, OpenInferenceSpanKind } from "arvo-core";
+/**
+ * Represents the input for a Multi ArvoEvent handler function.
+ */
+export type MultiArvoEventHandlerFunctionInput = {
+    event: ArvoEvent;
+};
+/**
+ * Represents the output of a Multi ArvoEvent handler function.
+ * @template TContract - The type of ArvoContract that the handler is associated with.
+ */
+export type MultiArvoEventHandlerFunctionOutput = Omit<CreateArvoEvent<Record<string, any>, string>, 'subject' | 'source' | 'executionunits' | 'traceparent' | 'tracestate'> & {
+    /**
+     * An optional override for the execution units of this specific event.
+     *
+     * @remarks
+     * Execution units represent the computational cost or resources required to process this event.
+     * If not provided, the default value defined in the handler's constructor will be used.
+     */
+    executionunits?: number;
+    /** Optional extensions for the event. */
+    __extensions?: Record<string, string | number | boolean>;
+};
+/**
+ * Defines the structure of a Multi ArvoEvent handler function.
+ * @template TContract - The type of ArvoContract that the handler is associated with.
+ */
+export type MultiArvoEventHandlerFunction = (param: MultiArvoEventHandlerFunctionInput) => Promise<MultiArvoEventHandlerFunctionOutput | void>;
+/**
+ * Interface for an Multi ArvoEvent handler.
+ */
+export interface IMultiArvoEventHandler {
+    /**
+     * The source definition of the MultiArvoEventHanlder.
+     *
+     * @remarks
+     * For all the events which are emitted by the handler, this will be the source
+     * field value of them all.
+     */
+    source: string;
+    /**
+     * The default execution cost of the function.
+     * This can represent a dollar value or some other number with a rate card.
+     */
+    executionunits: number;
+    /**
+     * The functional handler of the event which takes the input, performs an action, and returns the result.
+     * @param params - The input parameters for the handler function.
+     * @returns A promise of object containing the created ArvoEvent and optional extensions.
+     */
+    handler: MultiArvoEventHandlerFunction;
+    /**
+     * 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"
+     */
+    spanKind?: {
+        openInference?: OpenInferenceSpanKind;
+        arvoExecution?: ArvoExecutionSpanKind;
+        openTelemetry?: SpanKind;
+    };
+}

package/dist/MultiArvoEventHandler/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/OpenTelemetry/index.d.ts

@@ -0,0 +1,6 @@
+import { Context } from '@opentelemetry/api';
+/**
+ * A tracer instance for the ArvoEventHandler package.
+ */
+export declare const ArvoEventHandlerTracer: import("@opentelemetry/api").Tracer;
+export declare const extractContext: (traceparent: string, tracestate: string | null) => Context;

package/dist/OpenTelemetry/index.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractContext = exports.ArvoEventHandlerTracer = void 0;
+var api_1 = require("@opentelemetry/api");
+var utils_1 = require("./utils");
+var pkg = (0, utils_1.getPackageInfo)();
+/**
+ * A tracer instance for the ArvoEventHandler package.
+ */
+exports.ArvoEventHandlerTracer = api_1.trace.getTracer(pkg.name, pkg.version);
+// Helper function to extract context from traceparent and tracestate
+var extractContext = function (traceparent, tracestate) {
+    var extractedContext = api_1.propagation.extract(api_1.context.active(), {
+        traceparent: traceparent,
+        tracestate: tracestate || undefined,
+    });
+    return extractedContext;
+};
+exports.extractContext = extractContext;

package/dist/OpenTelemetry/utils.d.ts

@@ -0,0 +1,4 @@
+export declare function getPackageInfo(): {
+    name: string;
+    version: string;
+};

package/dist/OpenTelemetry/utils.js

@@ -0,0 +1,44 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPackageInfo = getPackageInfo;
+var fs = __importStar(require("fs"));
+var path = __importStar(require("path"));
+function getPackageInfo() {
+    try {
+        // Read the package.json file
+        var packageJsonPath = path.resolve(__dirname, '../../package.json');
+        var packageJsonContent = fs.readFileSync(packageJsonPath, 'utf-8');
+        // Parse the JSON content
+        var packageJson = JSON.parse(packageJsonContent);
+        // Extract name and version
+        var name_1 = packageJson.name, version = packageJson.version;
+        return { name: name_1, version: version };
+    }
+    catch (error) {
+        console.error('Error reading package.json:', error);
+        return { name: 'Unknown', version: 'Unknown' };
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,8 @@
+import ArvoEventHandler from './ArvoEventHandler';
+import { ArvoEventHandlerFunctionInput, ArvoEventHandlerFunctionOutput, ArvoEventHandlerFunction, IArvoEventHandler } from './ArvoEventHandler/types';
+import { createArvoEventHandler } from './ArvoEventHandler/helpers';
+import { PartialExcept } from './types';
+import MultiArvoEventHandler from './MultiArvoEventHandler';
+import { MultiArvoEventHandlerFunctionInput, MultiArvoEventHandlerFunctionOutput, MultiArvoEventHandlerFunction, IMultiArvoEventHandler } from './MultiArvoEventHandler/types';
+import { createMultiArvoEventHandler } from './MultiArvoEventHandler/helpers';
+export { ArvoEventHandler, createArvoEventHandler, IArvoEventHandler, ArvoEventHandlerFunctionOutput, ArvoEventHandlerFunctionInput, ArvoEventHandlerFunction, PartialExcept, MultiArvoEventHandler, MultiArvoEventHandlerFunctionInput, MultiArvoEventHandlerFunctionOutput, MultiArvoEventHandlerFunction, IMultiArvoEventHandler, createMultiArvoEventHandler, };

package/dist/index.js

@@ -0,0 +1,14 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createMultiArvoEventHandler = exports.MultiArvoEventHandler = exports.createArvoEventHandler = exports.ArvoEventHandler = void 0;
+var ArvoEventHandler_1 = __importDefault(require("./ArvoEventHandler"));
+exports.ArvoEventHandler = ArvoEventHandler_1.default;
+var helpers_1 = require("./ArvoEventHandler/helpers");
+Object.defineProperty(exports, "createArvoEventHandler", { enumerable: true, get: function () { return helpers_1.createArvoEventHandler; } });
+var MultiArvoEventHandler_1 = __importDefault(require("./MultiArvoEventHandler"));
+exports.MultiArvoEventHandler = MultiArvoEventHandler_1.default;
+var helpers_2 = require("./MultiArvoEventHandler/helpers");
+Object.defineProperty(exports, "createMultiArvoEventHandler", { enumerable: true, get: function () { return helpers_2.createMultiArvoEventHandler; } });

package/dist/types.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Creates a new type based on T where all properties are optional except for those specified in K.
+ *
+ * @template T - The original type.
+ * @template K - A union of keys from T that should remain required.
+ *
+ * @example
+ * interface User {
+ *   id: number;
+ *   name: string;
+ *   email: string;
+ * }
+ *
+ * type PartialUserExceptId = PartialExcept<User, 'id'>;
+ * // Equivalent to: { id: number; name?: string; email?: string; }
+ */
+export type PartialExcept<T, K extends keyof T> = Partial<Omit<T, K>> & Pick<T, K>;

package/dist/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -0,0 +1,54 @@
+{
+  "name": "arvo-event-handler",
+  "version": "0.0.1",
+  "description": "This package contains class and function for event handlers in an Arvo Event Driven system",
+  "main": "dist/index.js",
+  "scripts": {
+    "build": "tsc",
+    "start": "node ./dist/index.js",
+    "dev": "ts-node ./src/index.ts",
+    "test": "jest --passWithNoTests --runInBand --detectOpenHandles --forceExit",
+    "format": "npx prettier --write .",
+    "doc": "npx typedoc"
+  },
+  "keywords": [
+    "arvo",
+    "event-driven architecture",
+    "xorca",
+    "core",
+    "cloudevent",
+    "opentelemetry",
+    "orchestrator"
+  ],
+  "author": "Saad Ahmad <saadkwi12@hotmail.com>",
+  "license": "MIT",
+  "devDependencies": {
+    "@jest/globals": "^29.7.0",
+    "@opentelemetry/auto-instrumentations-node": "^0.49.1",
+    "@opentelemetry/exporter-metrics-otlp-proto": "^0.52.1",
+    "@opentelemetry/exporter-trace-otlp-grpc": "^0.53.0",
+    "@opentelemetry/exporter-trace-otlp-proto": "^0.52.1",
+    "@opentelemetry/resources": "^1.25.1",
+    "@opentelemetry/sdk-metrics": "^1.25.1",
+    "@opentelemetry/sdk-node": "^0.52.1",
+    "@opentelemetry/sdk-trace-node": "^1.25.1",
+    "@opentelemetry/semantic-conventions": "^1.25.1",
+    "@types/jest": "^29.5.12",
+    "@types/node": "^22.5.0",
+    "@types/uuid": "^10.0.0",
+    "dotenv": "^16.4.5",
+    "jest": "^29.7.0",
+    "prettier": "^3.3.3",
+    "ts-jest": "^29.2.5",
+    "ts-node": "^10.9.2",
+    "typedoc": "^0.26.6",
+    "typedoc-plugin-zod": "^1.2.1",
+    "typescript": "^5.5.4"
+  },
+  "dependencies": {
+    "@opentelemetry/api": "^1.9.0",
+    "arvo-core": "^1.0.26",
+    "uuid": "^10.0.0",
+    "zod": "^3.23.8"
+  }
+}