arvo-event-handler 3.0.6 → 3.0.8

package/dist/ArvoEventHandler/helpers.d.ts

@@ -1,6 +1,6 @@
 import type { ArvoContract } from 'arvo-core';
 import ArvoEventHandler from '.';
-import type { IArvoEventHandler } from './types';
+import type { ArvoEventHandlerParam } from './types';
 /**
  * Creates an instance of `ArvoEventHandler` for the specified versioned contract and handlers.
  *
@@ -42,4 +42,4 @@ import type { IArvoEventHandler } from './types';
  * @param param - Configuration object containing contract, versioned handlers, execution units, and span settings
  * @returns A fully configured `ArvoEventHandler` instance for the given contract
  */
-export declare const createArvoEventHandler: <TContract extends ArvoContract>(param: IArvoEventHandler<TContract>) => ArvoEventHandler<TContract>;
+export declare const createArvoEventHandler: <TContract extends ArvoContract>(param: ArvoEventHandlerParam<TContract>) => ArvoEventHandler<TContract>;

package/dist/ArvoEventHandler/index.d.ts

@@ -1,8 +1,8 @@
 import { type SpanOptions } from '@opentelemetry/api';
 import { type ArvoContract, type ArvoEvent } from 'arvo-core';
-import AbstractArvoEventHandler from '../AbstractArvoEventHandler';
+import type IArvoEventHandler from '../IArvoEventHandler';
 import type { ArvoEventHandlerOpenTelemetryOptions } from '../types';
-import type { ArvoEventHandlerFunction, IArvoEventHandler } from './types';
+import type { ArvoEventHandlerFunction, ArvoEventHandlerParam } from './types';
 /**
  * `ArvoEventHandler` is the foundational component for building stateless,
  * contract-bound services in the Arvo system.
@@ -83,7 +83,7 @@ import type { ArvoEventHandlerFunction, IArvoEventHandler } from './types';
  * - `'analytics.workflow'` → to pipe events into observability systems
  * - `'external.partner.sync'` → to route to external services
  */
-export default class ArvoEventHandler<TContract extends ArvoContract> extends AbstractArvoEventHandler {
+export default class ArvoEventHandler<TContract extends ArvoContract> implements IArvoEventHandler {
     /** Contract instance that defines the event schema and validation rules */
     readonly contract: TContract;
     /** Computational cost metric associated with event handling operations */
@@ -111,7 +111,7 @@ export default class ArvoEventHandler<TContract extends ArvoContract> extends Ab
      * @param param - Handler configuration including contract, execution units, and handler implementations
      * @throws When handler implementations are missing for any contract version
      */
-    constructor(param: IArvoEventHandler<TContract>);
+    constructor(param: ArvoEventHandlerParam<TContract>);
     /**
      * Processes an incoming event according to the handler's contract specifications. This method
      * handles the complete lifecycle of event processing including validation, execution, error

package/dist/ArvoEventHandler/index.js

@@ -1,19 +1,4 @@
 "use strict";
-var __extends = (this && this.__extends) || (function () {
-    var extendStatics = function (d, b) {
-        extendStatics = Object.setPrototypeOf ||
-            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
-            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
-        return extendStatics(d, b);
-    };
-    return function (d, b) {
-        if (typeof b !== "function" && b !== null)
-            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
-        extendStatics(d, b);
-        function __() { this.constructor = d; }
-        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++) {
@@ -72,16 +57,12 @@ var __rest = (this && this.__rest) || function (s, e) {
         }
     return t;
 };
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 var api_1 = require("@opentelemetry/api");
 var arvo_core_1 = require("arvo-core");
-var AbstractArvoEventHandler_1 = __importDefault(require("../AbstractArvoEventHandler"));
+var ArvoDomain_1 = require("../ArvoDomain");
 var errors_1 = require("../errors");
 var utils_1 = require("../utils");
-var ArvoDomain_1 = require("../ArvoDomain");
 /**
  * `ArvoEventHandler` is the foundational component for building stateless,
  * contract-bound services in the Arvo system.
@@ -162,8 +143,7 @@ var ArvoDomain_1 = require("../ArvoDomain");
  * - `'analytics.workflow'` → to pipe events into observability systems
  * - `'external.partner.sync'` → to route to external services
  */
-var ArvoEventHandler = /** @class */ (function (_super) {
-    __extends(ArvoEventHandler, _super);
+var ArvoEventHandler = /** @class */ (function () {
     /**
      * Initializes a new ArvoEventHandler instance with the specified contract and configuration.
      * Validates handler implementations against contract versions during initialization.
@@ -177,20 +157,18 @@ var ArvoEventHandler = /** @class */ (function (_super) {
     function ArvoEventHandler(param) {
         var _a;
         var _b, _c;
-        var _this = _super.call(this) || this;
-        _this.systemErrorDomain = undefined;
-        _this.contract = param.contract;
-        _this.executionunits = param.executionunits;
-        _this.handler = param.handler;
-        _this.systemErrorDomain = param.systemErrorDomain;
-        for (var _i = 0, _d = Object.keys(_this.contract.versions); _i < _d.length; _i++) {
+        this.systemErrorDomain = undefined;
+        this.contract = param.contract;
+        this.executionunits = param.executionunits;
+        this.handler = param.handler;
+        this.systemErrorDomain = param.systemErrorDomain;
+        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));
+            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.handler.source': _this.source, 'arvo.contract.uri': _this.contract.uri }) });
-        return _this;
+        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.handler.source': this.source, 'arvo.contract.uri': this.contract.uri }) });
     }
     Object.defineProperty(ArvoEventHandler.prototype, "source", {
         /** The source identifier for events produced by this handler */
@@ -308,6 +286,7 @@ var ArvoEventHandler = /** @class */ (function (_super) {
                                                             event: event.domain,
                                                         },
                                                         span: span,
+                                                        spanHeaders: otelSpanHeaders,
                                                     })];
                                             case 2:
                                                 _handleOutput = _z.sent();
@@ -441,5 +420,5 @@ var ArvoEventHandler = /** @class */ (function (_super) {
         configurable: true
     });
     return ArvoEventHandler;
-}(AbstractArvoEventHandler_1.default));
+}());
 exports.default = ArvoEventHandler;

package/dist/ArvoEventHandler/types.d.ts

@@ -1,5 +1,5 @@
 import type { Span, SpanOptions } from '@opentelemetry/api';
-import type { ArvoContract, ArvoEvent, ArvoSemanticVersion, CreateArvoEvent, InferArvoEvent, VersionedArvoContract } from 'arvo-core';
+import type { ArvoContract, ArvoEvent, ArvoSemanticVersion, CreateArvoEvent, InferArvoEvent, OpenTelemetryHeaders, VersionedArvoContract } from 'arvo-core';
 import type { z } from 'zod';
 /**
  * Represents the input for an ArvoEvent handler function.
@@ -18,6 +18,8 @@ export type ArvoEventHandlerFunctionInput<TContract extends VersionedArvoContrac
     contract: TContract;
     /** The OpenTelemetry span */
     span: Span;
+    /** The span headers */
+    spanHeaders: OpenTelemetryHeaders;
 };
 /**
  * Represents the output of an ArvoEvent handler function.
@@ -69,7 +71,7 @@ export type ArvoEventHandlerFunction<TContract extends ArvoContract> = {
 /**
  * Interface for an ArvoEvent handler.
  */
-export interface IArvoEventHandler<TContract extends ArvoContract> {
+export type ArvoEventHandlerParam<TContract extends ArvoContract> = {
     /**
      * The contract for the handler defining its input and outputs as well as the description.
      */
@@ -103,4 +105,4 @@ export interface IArvoEventHandler<TContract extends ArvoContract> {
      * @default undefined — uses standard fallback broadcast domains
      */
     systemErrorDomain?: (string | null)[];
-}
+};

package/dist/ArvoMachine/createMachine.d.ts

@@ -1,4 +1,4 @@
-import { type ArvoOrchestratorEventTypeGen, type InferVersionedArvoContract, type VersionedArvoContract } from 'arvo-core';
+import { type ArvoOrchestratorEventTypeGen, type CreateArvoEvent, type InferVersionedArvoContract, type VersionedArvoContract } from 'arvo-core';
 import { type ActionFunction, type MachineConfig, type MachineContext, type MetaObject, type ParameterizedObject, type SetupTypes } from 'xstate';
 import type { z } from 'zod';
 import ArvoMachine from '.';
@@ -185,7 +185,9 @@ export declare function setupArvoMachine<TContext extends MachineContext, TSelfC
 }): {
     createMachine: <const TConfig extends MachineConfig<TContext, InferServiceContract<TServiceContracts>["events"], ToProvidedActor<{}, {}>, ToParameterizedObject<TActions & {
         enqueueArvoEvent: EnqueueArvoEventActionParam;
-    }>, ToParameterizedObject<TGuards>, never, TTag, InferVersionedArvoContract<TSelfContract>["accepts"], z.input<TSelfContract["emits"][ReturnType<typeof ArvoOrchestratorEventTypeGen.complete<ExtractOrchestratorType<TSelfContract["accepts"]["type"]>>>]>, InferServiceContract<TServiceContracts>["emitted"], TMeta>>(config: TConfig & {
+    }>, ToParameterizedObject<TGuards>, never, TTag, InferVersionedArvoContract<TSelfContract>["accepts"], z.input<TSelfContract["emits"][ReturnType<typeof ArvoOrchestratorEventTypeGen.complete<ExtractOrchestratorType<TSelfContract["accepts"]["type"]>>>]> & {
+        __id?: CreateArvoEvent<Record<string, unknown>, string>["id"];
+    }, InferServiceContract<TServiceContracts>["emitted"], TMeta>>(config: TConfig & {
         id: string;
         version?: TSelfContract["version"];
     }) => ArvoMachine<string, TSelfContract["version"], TSelfContract, TServiceContracts, import("xstate").StateMachine<TContext, { [K in keyof TServiceContracts]: import("./types").InferEmittableEventsFromVersionedArvoContract<TServiceContracts[K]>; }[keyof TServiceContracts], {}, never, import("xstate").IsNever<TActions & {

package/dist/ArvoMachine/createMachine.js

@@ -25,11 +25,11 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.setupArvoMachine = setupArvoMachine;
 var arvo_core_1 = require("arvo-core");
+var uuid_1 = require("uuid");
 var xstate_1 = require("xstate");
 var _1 = __importDefault(require("."));
 var object_1 = require("../utils/object");
 var utils_1 = require("./utils");
-var uuid_1 = require("uuid");
 /**
  * Establishes the foundation for creating Arvo-compatible state machines.
  *

package/dist/ArvoMachine/types.d.ts

@@ -1,4 +1,4 @@
-import type { ArvoContract, ArvoEventData, ArvoOrchestratorEventTypeGen, ArvoSemanticVersion, CloudEventExtension, InferVersionedArvoContract, VersionedArvoContract } from 'arvo-core';
+import type { ArvoContract, ArvoEventData, ArvoOrchestratorEventTypeGen, ArvoSemanticVersion, CloudEventExtension, CreateArvoEvent, InferVersionedArvoContract, VersionedArvoContract } from 'arvo-core';
 import type { Invert, IsNever, ParameterizedObject, UnknownActorLogic, Values } from 'xstate';
 import type { z } from 'zod';
 /**
@@ -35,6 +35,10 @@ export type ArvoMachineContext = {
  * ```
  */
 export type EnqueueArvoEventActionParam<TData extends ArvoEventData = ArvoEventData, TType extends string = string, TExtension extends CloudEventExtension = CloudEventExtension> = {
+    /**
+     * The event id
+     */
+    id?: CreateArvoEvent<TData, TType>['id'];
     /**
      * The domain configuration for multi-domain event broadcasting.
      *

package/dist/ArvoOrchestrationUtils/createEmitableEvent.d.ts

@@ -0,0 +1,30 @@
+import type { Span } from '@opentelemetry/api';
+import { type ArvoEvent, type ArvoOrchestratorContract, type ArvoSemanticVersion, type OpenTelemetryHeaders, type VersionedArvoContract } from 'arvo-core';
+import type { EnqueueArvoEventActionParam } from '../ArvoMachine/types';
+export type CreateEmittableEventParams = {
+    event: EnqueueArvoEventActionParam;
+    otelHeaders: OpenTelemetryHeaders;
+    orchestrationParentSubject: string | null;
+    sourceEvent: ArvoEvent;
+    selfContract: VersionedArvoContract<ArvoOrchestratorContract, ArvoSemanticVersion>;
+    serviceContracts: Record<string, VersionedArvoContract<any, any>>;
+    initEventId: string;
+    domain: string | null;
+    executionunits: number;
+    source: string;
+};
+export declare const createEmittableEvent: ({ event, otelHeaders, orchestrationParentSubject, sourceEvent, selfContract, serviceContracts, initEventId, domain: _domain, executionunits, source, }: CreateEmittableEventParams, span: Span) => ArvoEvent;
+/**
+ * Processes raw events into emittable events with domain resolution
+ */
+export declare const processRawEventsIntoEmittables: (params: {
+    rawEvents: EnqueueArvoEventActionParam[];
+    otelHeaders: OpenTelemetryHeaders;
+    orchestrationParentSubject: string | null;
+    sourceEvent: ArvoEvent;
+    selfContract: VersionedArvoContract<ArvoOrchestratorContract, ArvoSemanticVersion>;
+    serviceContracts: Record<string, VersionedArvoContract<any, any>>;
+    initEventId: string;
+    executionunits: number;
+    source: string;
+}, span: Span) => ArvoEvent[];

package/dist/ArvoOrchestrationUtils/createEmitableEvent.js

@@ -0,0 +1,160 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.processRawEventsIntoEmittables = exports.createEmittableEvent = void 0;
+var arvo_core_1 = require("arvo-core");
+var ArvoDomain_1 = require("../ArvoDomain");
+var errors_1 = require("../errors");
+var createEmittableEvent = function (_a, span) {
+    var _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m;
+    var event = _a.event, otelHeaders = _a.otelHeaders, orchestrationParentSubject = _a.orchestrationParentSubject, sourceEvent = _a.sourceEvent, selfContract = _a.selfContract, serviceContracts = _a.serviceContracts, initEventId = _a.initEventId, _domain = _a.domain, executionunits = _a.executionunits, source = _a.source;
+    (0, arvo_core_1.logToSpan)({
+        level: 'INFO',
+        message: "Creating emittable event: ".concat(event.type),
+    }, span);
+    var serviceContractMap = Object.fromEntries(Object.values(serviceContracts).map(function (item) { return [
+        item.accepts.type,
+        item,
+    ]; }));
+    var schema = null;
+    var contract = null;
+    var subject = sourceEvent.subject;
+    var parentId = sourceEvent.id;
+    var domain = (0, ArvoDomain_1.resolveEventDomain)({
+        domainToResolve: _domain,
+        handlerSelfContract: selfContract,
+        eventContract: null,
+        triggeringEvent: sourceEvent,
+    });
+    if (event.type === selfContract.metadata.completeEventType) {
+        (0, arvo_core_1.logToSpan)({
+            level: 'INFO',
+            message: "Creating event for workflow completion: ".concat(event.type),
+        }, span);
+        contract = selfContract;
+        schema = selfContract.emits[selfContract.metadata.completeEventType];
+        subject = orchestrationParentSubject !== null && orchestrationParentSubject !== void 0 ? orchestrationParentSubject : sourceEvent.subject;
+        parentId = initEventId;
+        domain = (0, ArvoDomain_1.resolveEventDomain)({
+            domainToResolve: _domain,
+            handlerSelfContract: selfContract,
+            eventContract: selfContract,
+            triggeringEvent: sourceEvent,
+        });
+    }
+    else if (serviceContractMap[event.type]) {
+        (0, arvo_core_1.logToSpan)({
+            level: 'INFO',
+            message: "Creating service event for external system: ".concat(event.type),
+        }, span);
+        contract = serviceContractMap[event.type];
+        schema = serviceContractMap[event.type].accepts.schema;
+        domain = (0, ArvoDomain_1.resolveEventDomain)({
+            domainToResolve: _domain,
+            handlerSelfContract: selfContract,
+            eventContract: contract,
+            triggeringEvent: sourceEvent,
+        });
+        if (contract.metadata.contractType === 'ArvoOrchestratorContract') {
+            if (event.data.parentSubject$$) {
+                try {
+                    arvo_core_1.ArvoOrchestrationSubject.parse(event.data.parentSubject$$);
+                }
+                catch (_o) {
+                    throw new errors_1.ExecutionViolation("Invalid parentSubject$$ for the event(type='".concat(event.type, "', uri='").concat((_b = event.dataschema) !== null && _b !== void 0 ? _b : arvo_core_1.EventDataschemaUtil.create(contract), "'). It must be follow the ArvoOrchestrationSubject schema. The easiest way is to use the current orchestration subject by storing the subject via the context block in the machine definition."));
+                }
+            }
+            try {
+                if (event.data.parentSubject$$) {
+                    subject = arvo_core_1.ArvoOrchestrationSubject.from({
+                        orchestator: contract.accepts.type,
+                        version: contract.version,
+                        subject: event.data.parentSubject$$,
+                        domain: domain !== null && domain !== void 0 ? domain : null,
+                        meta: {
+                            redirectto: (_c = event.redirectto) !== null && _c !== void 0 ? _c : source,
+                        },
+                    });
+                }
+                else {
+                    subject = arvo_core_1.ArvoOrchestrationSubject.new({
+                        version: contract.version,
+                        orchestator: contract.accepts.type,
+                        initiator: source,
+                        domain: domain !== null && domain !== void 0 ? domain : undefined,
+                        meta: {
+                            redirectto: (_d = event.redirectto) !== null && _d !== void 0 ? _d : source,
+                        },
+                    });
+                }
+            }
+            catch (error) {
+                throw new errors_1.ExecutionViolation("Orchestration subject creation failed due to invalid parameters - Event: ".concat(event.type, " - ").concat(error === null || error === void 0 ? void 0 : error.message));
+            }
+        }
+    }
+    var finalDataschema = event.dataschema;
+    var finalData = event.data;
+    if (contract && schema) {
+        try {
+            finalData = schema.parse(event.data);
+            finalDataschema = arvo_core_1.EventDataschemaUtil.create(contract);
+        }
+        catch (error) {
+            throw new errors_1.ContractViolation("Invalid event data: Schema validation failed.\nEvent type: ".concat(event.type, "\nDetails: ").concat(error.message));
+        }
+    }
+    var emittableEvent = (0, arvo_core_1.createArvoEvent)({
+        id: event.id,
+        source: source,
+        type: event.type,
+        subject: subject,
+        dataschema: finalDataschema !== null && finalDataschema !== void 0 ? finalDataschema : undefined,
+        data: finalData,
+        to: (_e = event.to) !== null && _e !== void 0 ? _e : event.type,
+        accesscontrol: (_g = (_f = event.accesscontrol) !== null && _f !== void 0 ? _f : sourceEvent.accesscontrol) !== null && _g !== void 0 ? _g : undefined,
+        redirectto: (_h = event.redirectto) !== null && _h !== void 0 ? _h : source,
+        executionunits: (_j = event.executionunits) !== null && _j !== void 0 ? _j : executionunits,
+        traceparent: (_k = otelHeaders.traceparent) !== null && _k !== void 0 ? _k : undefined,
+        tracestate: (_l = otelHeaders.tracestate) !== null && _l !== void 0 ? _l : undefined,
+        parentid: parentId,
+        domain: domain !== null && domain !== void 0 ? domain : undefined,
+    }, (_m = event.__extensions) !== null && _m !== void 0 ? _m : {});
+    (0, arvo_core_1.logToSpan)({
+        level: 'INFO',
+        message: "Event created successfully: ".concat(emittableEvent.type),
+    }, span);
+    return emittableEvent;
+};
+exports.createEmittableEvent = createEmittableEvent;
+/**
+ * Processes raw events into emittable events with domain resolution
+ */
+var processRawEventsIntoEmittables = function (params, span) {
+    var _a;
+    var emittables = [];
+    for (var _i = 0, _b = params.rawEvents; _i < _b.length; _i++) {
+        var item = _b[_i];
+        for (var _c = 0, _d = Array.from(new Set((_a = item.domain) !== null && _a !== void 0 ? _a : [null])); _c < _d.length; _c++) {
+            var _dom = _d[_c];
+            var evt = (0, exports.createEmittableEvent)({
+                event: item,
+                otelHeaders: params.otelHeaders,
+                orchestrationParentSubject: params.orchestrationParentSubject,
+                sourceEvent: params.sourceEvent,
+                selfContract: params.selfContract,
+                serviceContracts: params.serviceContracts,
+                initEventId: params.initEventId,
+                domain: _dom,
+                executionunits: params.executionunits,
+                source: params.source,
+            }, span);
+            emittables.push(evt);
+            for (var _e = 0, _f = Object.entries(emittables[emittables.length - 1].otelAttributes); _e < _f.length; _e++) {
+                var _g = _f[_e], key = _g[0], value = _g[1];
+                span.setAttribute("to_emit.".concat(emittables.length - 1, ".").concat(key), value);
+            }
+        }
+    }
+    return emittables;
+};
+exports.processRawEventsIntoEmittables = processRawEventsIntoEmittables;

package/dist/ArvoOrchestrationUtils/error.d.ts

@@ -0,0 +1,18 @@
+import { type ArvoEvent, ViolationError } from 'arvo-core';
+export declare const TransactionViolationCause: {
+    readonly READ_FAILURE: "READ_MACHINE_MEMORY_FAILURE";
+    readonly LOCK_FAILURE: "LOCK_MACHINE_MEMORY_FAILURE";
+    readonly WRITE_FAILURE: "WRITE_MACHINE_MEMORY_FAILURE";
+    readonly LOCK_UNACQUIRED: "LOCK_UNACQUIRED";
+    readonly INVALID_SUBJECT: "INVALID_SUBJECT";
+};
+export type TransactionViolationCauseType = (typeof TransactionViolationCause)[keyof typeof TransactionViolationCause];
+export declare class TransactionViolation extends ViolationError<'OrchestratorTransaction'> {
+    readonly cause: TransactionViolationCauseType;
+    constructor(param: {
+        cause: TransactionViolationCauseType;
+        message: string;
+        initiatingEvent: ArvoEvent;
+    });
+}
+export declare const isTransactionViolationError: (error: unknown, cause?: TransactionViolationCauseType) => boolean;

package/dist/{ArvoOrchestrator → ArvoOrchestrationUtils}/error.js

@@ -15,16 +15,15 @@ var __extends = (this && this.__extends) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.TransactionViolation = exports.TransactionViolationCause = void 0;
+exports.isTransactionViolationError = exports.TransactionViolation = exports.TransactionViolationCause = void 0;
 var arvo_core_1 = require("arvo-core");
-var TransactionViolationCause;
-(function (TransactionViolationCause) {
-    TransactionViolationCause["READ_FAILURE"] = "READ_MACHINE_MEMORY_FAILURE";
-    TransactionViolationCause["LOCK_FAILURE"] = "LOCK_MACHINE_MEMORY_FAILURE";
-    TransactionViolationCause["WRITE_FAILURE"] = "WRITE_MACHINE_MEMORY_FAILURE";
-    TransactionViolationCause["LOCK_UNACQUIRED"] = "LOCK_UNACQUIRED";
-    TransactionViolationCause["INVALID_SUBJECT"] = "INVALID_SUBJECT";
-})(TransactionViolationCause || (exports.TransactionViolationCause = TransactionViolationCause = {}));
+exports.TransactionViolationCause = {
+    READ_FAILURE: 'READ_MACHINE_MEMORY_FAILURE',
+    LOCK_FAILURE: 'LOCK_MACHINE_MEMORY_FAILURE',
+    WRITE_FAILURE: 'WRITE_MACHINE_MEMORY_FAILURE',
+    LOCK_UNACQUIRED: 'LOCK_UNACQUIRED',
+    INVALID_SUBJECT: 'INVALID_SUBJECT',
+};
 var TransactionViolation = /** @class */ (function (_super) {
     __extends(TransactionViolation, _super);
     function TransactionViolation(param) {
@@ -41,3 +40,9 @@ var TransactionViolation = /** @class */ (function (_super) {
     return TransactionViolation;
 }(arvo_core_1.ViolationError));
 exports.TransactionViolation = TransactionViolation;
+var isTransactionViolationError = function (error, cause) {
+    return ((0, arvo_core_1.isViolationError)(error) &&
+        error.type === 'OrchestratorTransaction' &&
+        (cause ? error.cause === cause : true));
+};
+exports.isTransactionViolationError = isTransactionViolationError;

package/dist/ArvoOrchestrationUtils/handlerErrors.d.ts

@@ -0,0 +1,35 @@
+import { type Span } from '@opentelemetry/api';
+import { type ArvoEvent, type ArvoOrchestratorContract, type ArvoSemanticVersion, type OpenTelemetryHeaders, type VersionedArvoContract, type ViolationError } from 'arvo-core';
+import type { SyncEventResource } from '../SyncEventResource';
+import type { OrchestrationExecutionMemoryRecord } from './orchestrationExecutionState';
+import type { ArvoOrchestrationHandlerType } from './types';
+/**
+ * Parameters for system error event creation
+ */
+export type CreateSystemErrorEventsParams = {
+    error: unknown;
+    event: ArvoEvent;
+    otelHeaders: OpenTelemetryHeaders;
+    orchestrationParentSubject: string | null;
+    initEventId: string | null;
+    selfContract: VersionedArvoContract<ArvoOrchestratorContract, ArvoSemanticVersion>;
+    systemErrorDomain?: (string | null)[];
+    executionunits: number;
+    source: string;
+    domain: string | null;
+};
+/**
+ * Creates system error events
+ */
+export declare const createSystemErrorEvents: ({ error, event, otelHeaders, orchestrationParentSubject, initEventId, selfContract, systemErrorDomain, executionunits, source, domain, }: CreateSystemErrorEventsParams & {
+    error: Error;
+}) => ArvoEvent[];
+export declare const handleOrchestrationErrors: (_handlerType: ArvoOrchestrationHandlerType, param: CreateSystemErrorEventsParams & {
+    syncEventResource: SyncEventResource<OrchestrationExecutionMemoryRecord<Record<string, any>>>;
+}, span: Span) => Promise<{
+    errorToThrow: ViolationError;
+    events: null;
+} | {
+    errorToThrow: null;
+    events: ArvoEvent[];
+}>;