arvo-event-handler 3.0.7 → 3.0.10

package/dist/ArvoOrchestrationUtils/servicesValidation.js

@@ -0,0 +1,56 @@
+"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);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.servicesValidation = exports.areServiceContractsUnique = void 0;
+var uuid_1 = require("uuid");
+var errors_1 = require("../errors");
+var types_1 = require("./types");
+/**
+ * Validates that all service contracts in a collection have unique URIs.
+ *
+ * Iterates through the provided contracts and checks if any URI appears more than once.
+ * Multiple versions of the same contract (with the same URI) are not allowed.
+ *
+ * @param contracts - A record mapping contract keys to their respective ArvoContract objects
+ * @returns An object with a boolean result indicating if all contracts are unique, and the error keys if not
+ */
+var areServiceContractsUnique = function (contracts) {
+    var uriToKeyMap = {};
+    for (var _i = 0, _a = Object.entries(contracts); _i < _a.length; _i++) {
+        var _b = _a[_i], key = _b[0], contract = _b[1];
+        if (uriToKeyMap[contract.uri]) {
+            return {
+                result: false,
+                keys: [key, uriToKeyMap[contract.uri]],
+                contractUri: contract.uri,
+            };
+        }
+        uriToKeyMap[contract.uri] = key;
+    }
+    return {
+        result: true,
+    };
+};
+exports.areServiceContractsUnique = areServiceContractsUnique;
+var servicesValidation = function (contracts, _handlerType) {
+    var _a;
+    var __areServiceContractsUnique = (0, exports.areServiceContractsUnique)(contracts.services);
+    if (!__areServiceContractsUnique.result) {
+        throw new errors_1.ConfigViolation("In ".concat(types_1.ArvoOrchestrationHandlerMap[_handlerType], ", the service contracts must have unique URIs. Multiple versions of the same contract are not allow. The contracts '").concat(__areServiceContractsUnique.keys[0], "' and '").concat(__areServiceContractsUnique.keys[1], "' have the same URI '").concat(__areServiceContractsUnique.contractUri, "'"));
+    }
+    var __checkIfSelfIsAService = (0, exports.areServiceContractsUnique)(__assign(__assign({}, contracts.services), (_a = {}, _a[(0, uuid_1.v4)()] = contracts.self, _a)));
+    if (!__checkIfSelfIsAService.result) {
+        throw new errors_1.ConfigViolation("In ".concat(types_1.ArvoOrchestrationHandlerMap[_handlerType], ", Circular dependency detected: Machine with URI '").concat(contracts.self.uri, "' is registered as service '").concat(__checkIfSelfIsAService.keys[1], "'. Self-referential services create execution loops and are prohibited."));
+    }
+};
+exports.servicesValidation = servicesValidation;

package/dist/ArvoOrchestrationUtils/types.d.ts

@@ -0,0 +1,7 @@
+export declare const ArvoOrchestrationHandlerMap: {
+    readonly orchestrator: "ArvoOrchestrator";
+    readonly resumable: "ArvoResumable";
+    readonly machine: "ArvoMachine";
+    readonly handler: "ArvoEventHandler";
+};
+export type ArvoOrchestrationHandlerType = keyof typeof ArvoOrchestrationHandlerMap;

package/dist/ArvoOrchestrationUtils/types.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ArvoOrchestrationHandlerMap = void 0;
+exports.ArvoOrchestrationHandlerMap = {
+    orchestrator: 'ArvoOrchestrator',
+    resumable: 'ArvoResumable',
+    machine: 'ArvoMachine',
+    handler: 'ArvoEventHandler',
+};

package/dist/ArvoOrchestrator/factory.d.ts

@@ -1,5 +1,5 @@
 import { ArvoOrchestrator } from '.';
-import type { ICreateArvoOrchestrator } from './types';
+import type { CreateArvoOrchestratorParam } from './types';
 /**
  * Creates a new Arvo orchestrator instance with default components.
  * For custom components, use ArvoOrchestrator constructor directly.
@@ -26,4 +26,4 @@ import type { ICreateArvoOrchestrator } from './types';
  * });
  * ```
  */
-export declare const createArvoOrchestrator: ({ executionunits, memory, machines, systemErrorDomain, }: ICreateArvoOrchestrator) => ArvoOrchestrator;
+export declare const createArvoOrchestrator: ({ executionunits, memory, machines, systemErrorDomain, spanOptions, }: CreateArvoOrchestratorParam) => ArvoOrchestrator;

package/dist/ArvoOrchestrator/factory.js

@@ -13,6 +13,7 @@ exports.createArvoOrchestrator = void 0;
 var _1 = require(".");
 var MachineExecutionEngine_1 = require("../MachineExecutionEngine");
 var MachineRegistry_1 = require("../MachineRegistry");
+var errors_1 = require("../errors");
 /**
  * Creates a new Arvo orchestrator instance with default components.
  * For custom components, use ArvoOrchestrator constructor directly.
@@ -40,12 +41,24 @@ var MachineRegistry_1 = require("../MachineRegistry");
  * ```
  */
 var createArvoOrchestrator = function (_a) {
-    var executionunits = _a.executionunits, memory = _a.memory, machines = _a.machines, systemErrorDomain = _a.systemErrorDomain;
+    var executionunits = _a.executionunits, memory = _a.memory, machines = _a.machines, systemErrorDomain = _a.systemErrorDomain, spanOptions = _a.spanOptions;
     if (!(machines === null || machines === void 0 ? void 0 : machines.length)) {
         throw new Error('At least one machine must be provided');
     }
     var registry = new (MachineRegistry_1.MachineRegistry.bind.apply(MachineRegistry_1.MachineRegistry, __spreadArray([void 0], machines, false)))();
     var requiresResourceLocking = machines.some(function (machine) { return machine.requiresResourceLocking; });
+    var representativeMachine = registry.machines[0];
+    var lastSeenVersions = [];
+    for (var _i = 0, _b = registry.machines; _i < _b.length; _i++) {
+        var machine = _b[_i];
+        if (representativeMachine.source !== machine.source) {
+            throw new errors_1.ConfigViolation("All the machines in the orchestrator must have type '".concat(representativeMachine.source, "'"));
+        }
+        if (lastSeenVersions.includes(machine.version)) {
+            throw new errors_1.ConfigViolation("An orchestrator must have unique machine versions. Machine ID:".concat(machine.id, " has duplicate version ").concat(machine.version, "."));
+        }
+        lastSeenVersions.push(machine.version);
+    }
     return new _1.ArvoOrchestrator({
         executionunits: executionunits,
         memory: memory,
@@ -53,6 +66,7 @@ var createArvoOrchestrator = function (_a) {
         executionEngine: new MachineExecutionEngine_1.MachineExecutionEngine(),
         requiresResourceLocking: requiresResourceLocking,
         systemErrorDomain: systemErrorDomain,
+        spanOptions: spanOptions,
     });
 };
 exports.createArvoOrchestrator = createArvoOrchestrator;

package/dist/ArvoOrchestrator/index.d.ts

@@ -1,13 +1,11 @@
-import { type ArvoContractRecord, type ArvoEvent, type OpenTelemetryHeaders } from 'arvo-core';
-import type ArvoMachine from '../ArvoMachine';
-import type { EnqueueArvoEventActionParam } from '../ArvoMachine/types';
+import { type ArvoContractRecord, type ArvoEvent } from 'arvo-core';
+import type IArvoEventHandler from '../IArvoEventHandler';
 import type { IMachineExectionEngine } from '../MachineExecutionEngine/interface';
 import type { IMachineMemory } from '../MachineMemory/interface';
 import type { IMachineRegistry } from '../MachineRegistry/interface';
-import type { ArvoOrchestratorParam, MachineMemoryRecord } from './types';
 import { SyncEventResource } from '../SyncEventResource';
-import IArvoEventHandler from '../IArvoEventHandler';
 import type { ArvoEventHandlerOpenTelemetryOptions } from '../types';
+import type { ArvoOrchestratorParam, MachineMemoryRecord } from './types';
 /**
  * Orchestrates state machine execution and lifecycle management.
  * Handles machine resolution, state management, event processing and error handling.
@@ -18,6 +16,7 @@ export declare class ArvoOrchestrator implements IArvoEventHandler {
     readonly executionEngine: IMachineExectionEngine;
     readonly syncEventResource: SyncEventResource<MachineMemoryRecord>;
     readonly systemErrorDomain?: (string | null)[];
+    private readonly spanOptions;
     get source(): any;
     get requiresResourceLocking(): boolean;
     get memory(): IMachineMemory<MachineMemoryRecord>;
@@ -27,21 +26,7 @@ export declare class ArvoOrchestrator implements IArvoEventHandler {
      * @param params - Configuration parameters
      * @throws Error if machines in registry have different sources
      */
-    constructor({ executionunits, memory, registry, executionEngine, requiresResourceLocking, systemErrorDomain, }: ArvoOrchestratorParam);
-    /**
-     * Creates emittable event from execution result
-     * @param event - Source event to emit
-     * @param machine - Machine that generated event
-     * @param otelHeaders - OpenTelemetry headers
-     * @param orchestrationParentSubject - Parent orchestration subject
-     * @param sourceEvent - Original triggering event
-     * @param initEventId - The id of the event which initiated the orchestration in the first place
-     * @param _domain - The domain of the event.
-     *
-     * @throws {ContractViolation} On schema/contract mismatch
-     * @throws {ExecutionViolation} On invalid parentSubject$$ format
-     */
-    protected createEmittableEvent(event: EnqueueArvoEventActionParam, machine: ArvoMachine<any, any, any, any, any>, otelHeaders: OpenTelemetryHeaders, orchestrationParentSubject: string | null, sourceEvent: ArvoEvent, initEventId: string, _domain: string | null): ArvoEvent;
+    constructor({ executionunits, memory, registry, executionEngine, requiresResourceLocking, systemErrorDomain, spanOptions, }: ArvoOrchestratorParam);
     /**
      * Core orchestration method that executes state machines in response to events.
      *