arvo-core 2.1.0 → 2.1.2

package/dist/ArvoContract/VersionedArvoContract/index.d.ts

@@ -2,28 +2,26 @@ import ArvoContract from '..';
 import { ArvoSemanticVersion } from '../../types';
 import { ArvoContractRecord } from '../types';
 import { IVersionedArvoContract, VersionedArvoContractJSONSchema } from './types';
+import { transformEmitsToArray } from './utils';
 /**
  * Implements a version-specific view of an ArvoContract with type-safe schema validation
  * and JSON Schema generation capabilities.
  */
-export declare class VersionedArvoContract<TContract extends ArvoContract, TVersion extends ArvoSemanticVersion & keyof TContract['versions'], TMetaData extends Record<string, any> = Record<string, any>> {
-    private readonly _uri;
-    private readonly _version;
-    private readonly _description;
-    private readonly _accepts;
-    private readonly _emitMap;
-    private readonly _emits;
-    private readonly _metadata;
-    private readonly _systemError;
-    get uri(): TContract["uri"];
+export declare class VersionedArvoContract<TContract extends ArvoContract, TVersion extends ArvoSemanticVersion & keyof TContract['versions']> {
+    protected readonly _contract: TContract;
+    protected readonly _version: TVersion;
+    protected readonly _accepts: ArvoContractRecord<TContract['type'], TContract['versions'][TVersion]['accepts']>;
+    protected readonly _emits: TContract['versions'][TVersion]['emits'];
+    protected readonly _emitList: ReturnType<typeof transformEmitsToArray<TContract, TVersion>>;
+    get uri(): TContract['uri'];
     get version(): TVersion;
-    get description(): string | null;
+    get description(): TContract['description'];
+    get metadata(): TContract['metadata'];
+    get systemError(): TContract['systemError'];
     get accepts(): ArvoContractRecord<TContract["type"], TContract["versions"][TVersion]["accepts"]>;
-    get emitMap(): TContract["versions"][TVersion]["emits"];
-    get metadata(): TMetaData;
-    get systemError(): TContract["systemError"];
-    get emits(): { [K in keyof TContract["versions"][TVersion]["emits"] & string]: ArvoContractRecord<K, TContract["versions"][TVersion]["emits"][K]>; }[keyof TContract["versions"][TVersion]["emits"] & string][];
-    constructor(param: IVersionedArvoContract<TContract, TVersion, TMetaData>);
+    get emits(): TContract["versions"][TVersion]["emits"];
+    get emitList(): { [K in keyof TContract["versions"][TVersion]["emits"] & string]: ArvoContractRecord<K, TContract["versions"][TVersion]["emits"][K]>; }[keyof TContract["versions"][TVersion]["emits"] & string][];
+    constructor(param: IVersionedArvoContract<TContract, TVersion>);
     /**
      * Converts the contract to JSON Schema format
      * @returns Contract specification in JSON Schema format for documentation/serialization

package/dist/ArvoContract/VersionedArvoContract/index.js

@@ -13,18 +13,18 @@ var OpenTelemetry_1 = require("../../OpenTelemetry");
  */
 var VersionedArvoContract = /** @class */ (function () {
     function VersionedArvoContract(param) {
-        this._uri = param.uri;
         this._version = param.version;
-        this._description = param.description;
-        this._accepts = param.accepts;
-        this._emitMap = param.emits;
-        this._emits = (0, utils_1.transformEmitsToArray)(this.emitMap);
-        this._metadata = param.metadata;
-        this._systemError = param.systemError;
+        this._contract = param.contract;
+        this._accepts = {
+            type: param.contract.type,
+            schema: param.contract.versions[param.version].accepts,
+        };
+        this._emits = param.contract.versions[param.version].emits;
+        this._emitList = (0, utils_1.transformEmitsToArray)(this.emits);
     }
     Object.defineProperty(VersionedArvoContract.prototype, "uri", {
         get: function () {
-            return this._uri;
+            return this._contract.uri;
         },
         enumerable: false,
         configurable: true
@@ -38,42 +38,42 @@ var VersionedArvoContract = /** @class */ (function () {
     });
     Object.defineProperty(VersionedArvoContract.prototype, "description", {
         get: function () {
-            return this._description;
+            return this._contract.description;
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(VersionedArvoContract.prototype, "accepts", {
+    Object.defineProperty(VersionedArvoContract.prototype, "metadata", {
         get: function () {
-            return this._accepts;
+            return this._contract.metadata;
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(VersionedArvoContract.prototype, "emitMap", {
+    Object.defineProperty(VersionedArvoContract.prototype, "systemError", {
         get: function () {
-            return this._emitMap;
+            return this._contract.systemError;
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(VersionedArvoContract.prototype, "metadata", {
+    Object.defineProperty(VersionedArvoContract.prototype, "accepts", {
         get: function () {
-            return this._metadata;
+            return this._accepts;
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(VersionedArvoContract.prototype, "systemError", {
+    Object.defineProperty(VersionedArvoContract.prototype, "emits", {
         get: function () {
-            return this._systemError;
+            return this._emits;
         },
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(VersionedArvoContract.prototype, "emits", {
+    Object.defineProperty(VersionedArvoContract.prototype, "emitList", {
         get: function () {
-            return this._emits;
+            return this._emitList;
         },
         enumerable: false,
         configurable: true
@@ -85,19 +85,19 @@ var VersionedArvoContract = /** @class */ (function () {
     VersionedArvoContract.prototype.toJsonSchema = function () {
         try {
             return {
-                uri: this._uri,
-                description: this._description,
-                version: this._version,
-                metadata: this._metadata,
+                uri: this.uri,
+                description: this.description,
+                version: this.version,
+                metadata: this.metadata,
                 accepts: {
                     type: this._accepts.type,
                     schema: (0, zod_to_json_schema_1.default)(this._accepts.schema),
                 },
                 systemError: {
-                    type: this._systemError.type,
-                    schema: (0, zod_to_json_schema_1.default)(this._systemError.schema),
+                    type: this.systemError.type,
+                    schema: (0, zod_to_json_schema_1.default)(this.systemError.schema),
                 },
-                emits: Object.entries(this._emitMap).map(function (_a) {
+                emits: Object.entries(this._emits).map(function (_a) {
                     var key = _a[0], value = _a[1];
                     return ({
                         type: key,

package/dist/ArvoContract/VersionedArvoContract/types.d.ts

@@ -1,20 +1,14 @@
 import zodToJsonSchema from 'zod-to-json-schema';
 import ArvoContract from '..';
 import { ArvoSemanticVersion } from '../../types';
-import { ArvoContractRecord } from '../types';
 /**
  * Represents a version-specific view of an ArvoContract, providing type-safe access
  * to contract specifications for a particular semantic version. This interface acts as
  * a bridge between the base contract and its versioned implementation.
  */
-export interface IVersionedArvoContract<TContract extends ArvoContract, TVersion extends ArvoSemanticVersion & keyof TContract['versions'], TMetaData extends Record<string, any> = Record<string, any>> {
-    uri: TContract['uri'];
+export interface IVersionedArvoContract<TContract extends ArvoContract, TVersion extends ArvoSemanticVersion & keyof TContract['versions']> {
+    contract: TContract;
     version: TVersion;
-    description: string | null;
-    accepts: ArvoContractRecord<TContract['type'], TContract['versions'][TVersion]['accepts']>;
-    systemError: TContract['systemError'];
-    emits: TContract['versions'][TVersion]['emits'];
-    metadata: TMetaData;
 }
 /**
  * Represents the standardized JSON Schema structure for an Arvo contract record.

package/dist/ArvoContract/index.d.ts

@@ -41,11 +41,11 @@ export default class ArvoContract<TUri extends string = string, TType extends st
     accepts: z.ZodTypeAny;
     emits: Record<string, z.ZodTypeAny>;
 }>, TMetaData extends Record<string, any> = Record<string, any>> {
-    private readonly _uri;
-    private readonly _type;
-    private readonly _versions;
-    private readonly _description;
-    private readonly _metadata;
+    protected readonly _uri: TUri;
+    protected readonly _type: TType;
+    protected readonly _versions: TVersions;
+    protected readonly _description: string | null;
+    protected readonly _metadata: TMetaData;
     get uri(): TUri;
     get type(): TType;
     get versions(): TVersions;
@@ -93,7 +93,7 @@ export default class ArvoContract<TUri extends string = string, TType extends st
      *
      * @throws {Error} When an invalid or non-existent version is requested
      */
-    version<V extends (ArvoSemanticVersion & keyof TVersions) | 'any' | 'latest' | 'oldest'>(option: V): V extends ArvoSemanticVersion & keyof TVersions ? VersionedArvoContract<typeof this, V, TMetaData> : VersionedArvoContract<any, any, any>;
+    version<V extends (ArvoSemanticVersion & keyof TVersions) | 'any' | 'latest' | 'oldest'>(option: V): V extends ArvoSemanticVersion & keyof TVersions ? VersionedArvoContract<typeof this, V> : VersionedArvoContract<any, any>;
     /**
      * Retrieves version numbers in sorted order based on semantic versioning rules.
      * @returns Array of semantic versions sorted according to specified ordering

package/dist/ArvoContract/index.js

@@ -162,16 +162,8 @@ var ArvoContract = /** @class */ (function () {
             resolvedVersion = option;
         }
         return new VersionedArvoContract_1.VersionedArvoContract({
-            uri: this._uri,
-            description: this._description,
+            contract: this,
             version: resolvedVersion,
-            accepts: {
-                type: this._type,
-                schema: this._versions[resolvedVersion].accepts,
-            },
-            systemError: this.systemError,
-            emits: this._versions[resolvedVersion].emits,
-            metadata: this._metadata,
         }); // needed due to TypeScript limitations with conditional types
     };
     /**

package/dist/ArvoEventFactory/Orchestrator.d.ts

@@ -0,0 +1,45 @@
+import ArvoEventFactory from '.';
+import { z } from 'zod';
+import { CreateArvoEvent } from '../ArvoEvent/types';
+import { ExecutionOpenTelemetryConfiguration } from '../OpenTelemetry/types';
+import { VersionedArvoContract } from '../ArvoContract/VersionedArvoContract';
+/**
+ * Factory class for creating and validating orchestrator-specific events with managed subject hierarchies.
+ * Extends ArvoEventFactory with parent-child subject relationship handling and orchestration flows.
+ *
+ * @example
+ * ```typescript
+ * const contract = createArvoOrchestratorContract({ ... });
+ *
+ * const factory = createArvoOrchestratorEventFactory(contract.version('1.0.0'));
+ * ```
+ */
+export declare class ArvoOrchestratorEventFactory<TContract extends VersionedArvoContract<any, any>> extends ArvoEventFactory<TContract> {
+    protected readonly _name: string;
+    constructor(contract: TContract);
+    /**
+     * Initializes a new orchestration event, handling parent-child subject relationships.
+     * - If parentSubject$$ is provided, creates a child subject
+     * - If no parent, creates a new root orchestration subject
+     *
+     * @param event - Event configuration without type/schema/subject
+     * @param [extensions] - Optional additional properties
+     * @param [opentelemetry] - Optional telemetry configuration
+     * @returns Validated orchestration event with proper subject hierarchy
+     *
+     * @throws Error if event validation fails
+     */
+    init<TExtension extends Record<string, any>>(event: Omit<CreateArvoEvent<z.input<TContract['accepts']['schema']>, TContract['accepts']['type']>, 'type' | 'datacontenttype' | 'dataschema' | 'subject'>, extensions?: TExtension, opentelemetry?: ExecutionOpenTelemetryConfiguration): import("..").ArvoEvent<z.TypeOf<TContract["accepts"]["schema"]>, TExtension, TContract["accepts"]["type"]>;
+    /**
+     * Creates a completion event for the orchestration flow.
+     * Uses the contract's configured complete event type from metadata.
+     *
+     * @param event - Completion event configuration
+     * @param [extensions] - Optional additional properties
+     * @param [opentelemetry] - Optional telemetry configuration
+     * @returns Validated completion event
+     *
+     * @throws Error if event validation fails or complete event type not configured
+     */
+    complete<TExtension extends Record<string, any>>(event: Omit<CreateArvoEvent<z.input<TContract['emits'][TContract['metadata']['completeEventType']]>, TContract['metadata']['completeEventType']>, 'datacontenttype' | 'dataschema' | 'type'>, extensions?: TExtension, opentelemetry?: ExecutionOpenTelemetryConfiguration): import("..").ArvoEvent<z.TypeOf<TContract["emits"][TContract["metadata"]["completeEventType"]]>, TExtension, TContract["metadata"]["completeEventType"]>;
+}

package/dist/ArvoEventFactory/Orchestrator.js

@@ -0,0 +1,161 @@
+"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++) {
+            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 __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ArvoOrchestratorEventFactory = void 0;
+var _1 = __importDefault(require("."));
+var helpers_1 = require("../ArvoEvent/helpers");
+var schema_1 = require("../ArvoEvent/schema");
+var OpenTelemetry_1 = require("../OpenTelemetry");
+var api_1 = require("@opentelemetry/api");
+var utils_1 = require("../utils");
+var ArvoOrchestrationSubject_1 = __importDefault(require("../ArvoOrchestrationSubject"));
+/**
+ * Factory class for creating and validating orchestrator-specific events with managed subject hierarchies.
+ * Extends ArvoEventFactory with parent-child subject relationship handling and orchestration flows.
+ *
+ * @example
+ * ```typescript
+ * const contract = createArvoOrchestratorContract({ ... });
+ *
+ * const factory = createArvoOrchestratorEventFactory(contract.version('1.0.0'));
+ * ```
+ */
+var ArvoOrchestratorEventFactory = /** @class */ (function (_super) {
+    __extends(ArvoOrchestratorEventFactory, _super);
+    function ArvoOrchestratorEventFactory(contract) {
+        var _this = this;
+        var _a;
+        if (((_a = contract.metadata) === null || _a === void 0 ? void 0 : _a.contractType) !== 'ArvoOrchestratorContract') {
+            throw new Error("This factory can only be used for ArvoOrchestratorContract");
+        }
+        _this = _super.call(this, contract) || this;
+        _this._name = 'ArvoOrchestratorEventFactory';
+        return _this;
+    }
+    /**
+     * Initializes a new orchestration event, handling parent-child subject relationships.
+     * - If parentSubject$$ is provided, creates a child subject
+     * - If no parent, creates a new root orchestration subject
+     *
+     * @param event - Event configuration without type/schema/subject
+     * @param [extensions] - Optional additional properties
+     * @param [opentelemetry] - Optional telemetry configuration
+     * @returns Validated orchestration event with proper subject hierarchy
+     *
+     * @throws Error if event validation fails
+     */
+    ArvoOrchestratorEventFactory.prototype.init = function (event, extensions, opentelemetry) {
+        var _this = this;
+        opentelemetry = opentelemetry !== null && opentelemetry !== void 0 ? opentelemetry : {
+            tracer: (0, OpenTelemetry_1.fetchOpenTelemetryTracer)(),
+        };
+        var span = opentelemetry.tracer.startSpan("".concat(this._name, "<").concat(this.contract.uri, "/").concat(this.contract.version, ">.init"));
+        return api_1.context.with(api_1.trace.setSpan(api_1.context.active(), span), function () {
+            var _a, _b, _c, _d;
+            span.setStatus({ code: api_1.SpanStatusCode.OK });
+            var otelHeaders = (0, OpenTelemetry_1.currentOpenTelemetryHeaders)();
+            try {
+                var validationResult = _this.contract.accepts.schema.safeParse(event.data);
+                if (!validationResult.success) {
+                    throw new Error("Accept Event data validation failed: ".concat(validationResult.error.message));
+                }
+                var parentSubject = validationResult.data.parentSubject$$;
+                var newSubject = parentSubject
+                    ? ArvoOrchestrationSubject_1.default.from({
+                        orchestator: _this.contract.accepts.type,
+                        subject: parentSubject,
+                        version: _this.contract.version,
+                    })
+                    : ArvoOrchestrationSubject_1.default.new({
+                        orchestator: _this.contract.accepts.type,
+                        initiator: event.source,
+                        version: _this.contract.version,
+                    });
+                return (0, helpers_1.createArvoEvent)(__assign(__assign({}, event), { subject: newSubject, traceparent: (_b = (_a = event.traceparent) !== null && _a !== void 0 ? _a : otelHeaders.traceparent) !== null && _b !== void 0 ? _b : undefined, tracestate: (_d = (_c = event.tracestate) !== null && _c !== void 0 ? _c : otelHeaders.tracestate) !== null && _d !== void 0 ? _d : undefined, type: _this.contract.accepts.type, datacontenttype: schema_1.ArvoDataContentType, dataschema: utils_1.EventDataschemaUtil.create(_this.contract), data: validationResult.data }), extensions, { disable: true });
+            }
+            catch (error) {
+                (0, OpenTelemetry_1.exceptionToSpan)(error);
+                span.setStatus({
+                    code: api_1.SpanStatusCode.ERROR,
+                    message: error.message,
+                });
+                throw error;
+            }
+            finally {
+                span.end();
+            }
+        });
+    };
+    /**
+     * Creates a completion event for the orchestration flow.
+     * Uses the contract's configured complete event type from metadata.
+     *
+     * @param event - Completion event configuration
+     * @param [extensions] - Optional additional properties
+     * @param [opentelemetry] - Optional telemetry configuration
+     * @returns Validated completion event
+     *
+     * @throws Error if event validation fails or complete event type not configured
+     */
+    ArvoOrchestratorEventFactory.prototype.complete = function (event, extensions, opentelemetry) {
+        var _this = this;
+        opentelemetry = opentelemetry !== null && opentelemetry !== void 0 ? opentelemetry : {
+            tracer: (0, OpenTelemetry_1.fetchOpenTelemetryTracer)(),
+        };
+        var span = opentelemetry.tracer.startSpan("".concat(this._name, "<").concat(this.contract.uri, "/").concat(this.contract.version, ">.complete"));
+        return api_1.context.with(api_1.trace.setSpan(api_1.context.active(), span), function () {
+            var _a, _b, _c, _d, _e, _f, _g, _h;
+            span.setStatus({ code: api_1.SpanStatusCode.OK });
+            var otelHeaders = (0, OpenTelemetry_1.currentOpenTelemetryHeaders)();
+            try {
+                var validationResult = (_b = (_a = _this.contract.emits) === null || _a === void 0 ? void 0 : _a[_this.contract.metadata.completeEventType]) === null || _b === void 0 ? void 0 : _b.safeParse(event.data);
+                if (!(validationResult === null || validationResult === void 0 ? void 0 : validationResult.success)) {
+                    var msg = (_d = (_c = validationResult === null || validationResult === void 0 ? void 0 : validationResult.error) === null || _c === void 0 ? void 0 : _c.message) !== null && _d !== void 0 ? _d : "No contract available for ".concat(_this.contract.metadata.completeEventType);
+                    throw new Error("Emit Event data validation failed: ".concat(msg));
+                }
+                return (0, helpers_1.createArvoEvent)(__assign(__assign({}, event), { type: _this.contract.metadata.completeEventType, traceparent: (_f = (_e = event.traceparent) !== null && _e !== void 0 ? _e : otelHeaders.traceparent) !== null && _f !== void 0 ? _f : undefined, tracestate: (_h = (_g = event.tracestate) !== null && _g !== void 0 ? _g : otelHeaders.tracestate) !== null && _h !== void 0 ? _h : undefined, datacontenttype: schema_1.ArvoDataContentType, dataschema: utils_1.EventDataschemaUtil.create(_this.contract), data: validationResult.data }), extensions, { disable: true });
+            }
+            catch (error) {
+                (0, OpenTelemetry_1.exceptionToSpan)(error);
+                span.setStatus({
+                    code: api_1.SpanStatusCode.ERROR,
+                    message: error.message,
+                });
+                throw error;
+            }
+            finally {
+                span.end();
+            }
+        });
+    };
+    return ArvoOrchestratorEventFactory;
+}(_1.default));
+exports.ArvoOrchestratorEventFactory = ArvoOrchestratorEventFactory;

package/dist/ArvoEventFactory/helpers.d.ts

@@ -1,7 +1,6 @@
 import ArvoEventFactory from '.';
-import ArvoContract from '../ArvoContract';
-import { ArvoSemanticVersion } from '../types';
 import { VersionedArvoContract } from '../ArvoContract/VersionedArvoContract';
+import { ArvoOrchestratorEventFactory } from './Orchestrator';
 /**
  * Creates an ArvoEventFactory for a specific version of a contract.
  *
@@ -15,4 +14,22 @@ import { VersionedArvoContract } from '../ArvoContract/VersionedArvoContract';
  * const factory = createArvoEventFactory(v1Contract);
  * ```
  */
-export declare const createArvoEventFactory: <TContract extends VersionedArvoContract<ArvoContract<any, any, any, any>, ArvoSemanticVersion, Record<string, any>>>(contract: TContract) => ArvoEventFactory<TContract>;
+export declare const createArvoEventFactory: <TContract extends VersionedArvoContract<any, any>>(contract: TContract) => ArvoEventFactory<TContract>;
+/**
+ * Creates an ArvoOrchestratorEventFactory instance for handling orchestration events.
+ * Provides type-safe event creation with parent-child subject relationship handling.
+ *
+ * @param contract - The versioned contract for orchestration events
+ * @returns An ArvoOrchestratorEventFactory for creating orchestration events
+ *
+ * @example
+ * ```typescript
+ * const contract = createArvoOrchestratorContract({ ... });
+ * const factory = createArvoOrchestratorEventFactory(contract.version('1.0.0'));
+ * const event = factory.init({
+ *   source: 'system',
+ *   data: { parentSubject$$: null, data: 'value' }
+ * });
+ * ```
+ */
+export declare const createArvoOrchestratorEventFactory: <TContract extends VersionedArvoContract<any, any>>(contract: TContract) => ArvoOrchestratorEventFactory<TContract>;

package/dist/ArvoEventFactory/helpers.js

@@ -3,8 +3,9 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createArvoEventFactory = void 0;
+exports.createArvoOrchestratorEventFactory = exports.createArvoEventFactory = void 0;
 var _1 = __importDefault(require("."));
+var Orchestrator_1 = require("./Orchestrator");
 /**
  * Creates an ArvoEventFactory for a specific version of a contract.
  *
@@ -20,3 +21,22 @@ var _1 = __importDefault(require("."));
  */
 var createArvoEventFactory = function (contract) { return new _1.default(contract); };
 exports.createArvoEventFactory = createArvoEventFactory;
+/**
+ * Creates an ArvoOrchestratorEventFactory instance for handling orchestration events.
+ * Provides type-safe event creation with parent-child subject relationship handling.
+ *
+ * @param contract - The versioned contract for orchestration events
+ * @returns An ArvoOrchestratorEventFactory for creating orchestration events
+ *
+ * @example
+ * ```typescript
+ * const contract = createArvoOrchestratorContract({ ... });
+ * const factory = createArvoOrchestratorEventFactory(contract.version('1.0.0'));
+ * const event = factory.init({
+ *   source: 'system',
+ *   data: { parentSubject$$: null, data: 'value' }
+ * });
+ * ```
+ */
+var createArvoOrchestratorEventFactory = function (contract) { return new Orchestrator_1.ArvoOrchestratorEventFactory(contract); };
+exports.createArvoOrchestratorEventFactory = createArvoOrchestratorEventFactory;

package/dist/ArvoEventFactory/index.d.ts

@@ -18,8 +18,9 @@ import { VersionedArvoContract } from '../ArvoContract/VersionedArvoContract';
  * const factory = createArvoEventFactory(contract.version('1.0.0'));
  * ```
  */
-export default class ArvoEventFactory<TContract extends VersionedArvoContract<any, any, any>> {
-    private readonly contract;
+export default class ArvoEventFactory<TContract extends VersionedArvoContract<any, any>> {
+    protected readonly _name: string;
+    protected readonly contract: TContract;
     /**
      * Creates an ArvoEventFactory instance for a specific version of a contract.
      *
@@ -66,7 +67,7 @@ export default class ArvoEventFactory<TContract extends VersionedArvoContract<an
      * });
      * ```
      */
-    emits<U extends string & keyof TContract['emitMap'], TExtension extends Record<string, any>>(event: Omit<CreateArvoEvent<z.input<TContract['emitMap'][U]>, U>, 'datacontenttype' | 'dataschema'>, extensions?: TExtension, opentelemetry?: ExecutionOpenTelemetryConfiguration): import("..").ArvoEvent<z.TypeOf<TContract["emitMap"][U]>, TExtension, U>;
+    emits<U extends string & keyof TContract['emits'], TExtension extends Record<string, any>>(event: Omit<CreateArvoEvent<z.input<TContract['emits'][U]>, U>, 'datacontenttype' | 'dataschema'>, extensions?: TExtension, opentelemetry?: ExecutionOpenTelemetryConfiguration): import("..").ArvoEvent<z.TypeOf<TContract["emits"][U]>, TExtension, U>;
     /**
      * Creates a system error event for error reporting and handling.
      *

package/dist/ArvoEventFactory/index.js

@@ -50,6 +50,7 @@ var ArvoEventFactory = /** @class */ (function () {
      * @param contract - The versioned contract to use for event creation and validation
      */
     function ArvoEventFactory(contract) {
+        this._name = 'ArvoEventFactory';
         this.contract = contract;
     }
     /**
@@ -76,7 +77,7 @@ var ArvoEventFactory = /** @class */ (function () {
         opentelemetry = opentelemetry !== null && opentelemetry !== void 0 ? opentelemetry : {
             tracer: (0, OpenTelemetry_1.fetchOpenTelemetryTracer)(),
         };
-        var span = opentelemetry.tracer.startSpan("ArvoEventFactory<".concat(this.contract.uri, "/").concat(this.contract.version, ">.accepts"));
+        var span = opentelemetry.tracer.startSpan("".concat(this._name, "<").concat(this.contract.uri, "/").concat(this.contract.version, ">.accepts"));
         return api_1.context.with(api_1.trace.setSpan(api_1.context.active(), span), function () {
             var _a, _b, _c, _d;
             span.setStatus({ code: api_1.SpanStatusCode.OK });
@@ -126,13 +127,13 @@ var ArvoEventFactory = /** @class */ (function () {
         opentelemetry = opentelemetry !== null && opentelemetry !== void 0 ? opentelemetry : {
             tracer: (0, OpenTelemetry_1.fetchOpenTelemetryTracer)(),
         };
-        var span = opentelemetry.tracer.startSpan("ArvoEventFactory<".concat(this.contract.uri, "/").concat(this.contract.version, ">.emits<").concat(event.type, ">"));
+        var span = opentelemetry.tracer.startSpan("".concat(this._name, "<").concat(this.contract.uri, "/").concat(this.contract.version, ">.emits<").concat(event.type, ">"));
         return api_1.context.with(api_1.trace.setSpan(api_1.context.active(), span), function () {
             var _a, _b, _c, _d, _e, _f, _g, _h;
             span.setStatus({ code: api_1.SpanStatusCode.OK });
             var otelHeaders = (0, OpenTelemetry_1.currentOpenTelemetryHeaders)();
             try {
-                var validationResult = (_b = (_a = _this.contract.emitMap) === null || _a === void 0 ? void 0 : _a[event.type]) === null || _b === void 0 ? void 0 : _b.safeParse(event.data);
+                var validationResult = (_b = (_a = _this.contract.emits) === null || _a === void 0 ? void 0 : _a[event.type]) === null || _b === void 0 ? void 0 : _b.safeParse(event.data);
                 if (!(validationResult === null || validationResult === void 0 ? void 0 : validationResult.success)) {
                     var msg = (_d = (_c = validationResult === null || validationResult === void 0 ? void 0 : validationResult.error) === null || _c === void 0 ? void 0 : _c.message) !== null && _d !== void 0 ? _d : "No contract available for ".concat(event.type);
                     throw new Error("Emit Event data validation failed: ".concat(msg));
@@ -177,7 +178,7 @@ var ArvoEventFactory = /** @class */ (function () {
         opentelemetry = opentelemetry !== null && opentelemetry !== void 0 ? opentelemetry : {
             tracer: (0, OpenTelemetry_1.fetchOpenTelemetryTracer)(),
         };
-        var span = opentelemetry.tracer.startSpan("ArvoEventFactory<".concat(this.contract.uri, ">.systemError"));
+        var span = opentelemetry.tracer.startSpan("".concat(this._name, "<").concat(this.contract.uri, ">.systemError"));
         return api_1.context.with(api_1.trace.setSpan(api_1.context.active(), span), function () {
             var _a, _b, _c, _d, _e;
             span.setStatus({ code: api_1.SpanStatusCode.OK });

package/dist/index.d.ts

@@ -10,7 +10,7 @@ import { createArvoContract } from './ArvoContract/helpers';
 import { ArvoContractValidators } from './ArvoContract/validators';
 import { ArvoContractRecord, IArvoContract, ResolveArvoContractRecord, ArvoContractJSONSchema } from './ArvoContract/types';
 import ArvoEventFactory from './ArvoEventFactory';
-import { createArvoEventFactory } from './ArvoEventFactory/helpers';
+import { createArvoEventFactory, createArvoOrchestratorEventFactory } from './ArvoEventFactory/helpers';
 import { ArvoErrorSchema, ArvoSemanticVersionSchema, isValidArvoSemanticVersion } from './schema';
 import OpenInference from './OpenTelemetry/OpenInference';
 import ArvoExecution from './OpenTelemetry/ArvoExecution';
@@ -29,8 +29,7 @@ import { VersionedArvoContract } from './ArvoContract/VersionedArvoContract';
 import { isWildCardArvoSematicVersion, WildCardArvoSemanticVersion } from './ArvoContract/WildCardArvoSemanticVersion';
 import { createSimpleArvoContract } from './ArvoContract/SimpleArvoContract';
 import { SimpleArvoContract } from './ArvoContract/SimpleArvoContract/types';
-type AnyArvoContract = ArvoContract<any, any, any, any>;
-type AnyVersionedArvoContract = VersionedArvoContract<any, any>;
+import { ArvoOrchestratorEventFactory } from './ArvoEventFactory/Orchestrator';
 /**
  * Collection of Zod schemas for validating various aspects of Arvo events.
  * @property {z.ZodObject} CloudEventContextSchema - Schema for core CloudEvent properties.
@@ -105,4 +104,4 @@ declare const ArvoEventSchema: {
         parentSubject$$: string | null;
     }>;
 };
-export { ArvoEventHttpConfig, ArvoEventHttp, ArvoEvent, createArvoEvent, ArvoDataContentType, ArvoEventData, CloudEventExtension, ArvoEventSchema, CloudEventContext, ArvoExtension, OpenTelemetryExtension, CreateArvoEvent, exceptionToSpan, logToSpan, OpenTelemetryHeaders, TelemetryLogLevel, OTelNull, validateURI, cleanString, ArvoContract, createArvoContract, ArvoContractValidators, ArvoContractRecord, IArvoContract, ResolveArvoContractRecord, ArvoEventFactory, createArvoEventFactory, currentOpenTelemetryHeaders, OpenInference, OpenInferenceSpanKind, ArvoExecution, ArvoExecutionSpanKind, ArvoContractJSONSchema, ArvoOrchestrationSubject, ArvoOrchestrationSubjectContent, ArvoSemanticVersion, InferArvoEvent, createArvoOrchestratorContract, ICreateArvoOrchestratorContract, ArvoOrchestratorEventTypeGen, ExecutionOpenTelemetryConfiguration, EventDataschemaUtil, ArvoOrchestrationSubjectContentSchema, ArvoSemanticVersionSchema, ArvoErrorSchema, ArvoErrorType, compareSemanticVersions, parseSemanticVersion, createSimpleArvoContract, ArvoOrchestratorContract, VersionedArvoContract, InferVersionedArvoContract, isWildCardArvoSematicVersion, WildCardArvoSemanticVersion, isValidArvoSemanticVersion, SimpleArvoContract, AnyArvoContract, AnyVersionedArvoContract, };
+export { ArvoEventHttpConfig, ArvoEventHttp, ArvoEvent, createArvoEvent, ArvoDataContentType, ArvoEventData, CloudEventExtension, ArvoEventSchema, CloudEventContext, ArvoExtension, OpenTelemetryExtension, CreateArvoEvent, exceptionToSpan, logToSpan, OpenTelemetryHeaders, TelemetryLogLevel, OTelNull, validateURI, cleanString, ArvoContract, createArvoContract, ArvoContractValidators, ArvoContractRecord, IArvoContract, ResolveArvoContractRecord, ArvoEventFactory, createArvoEventFactory, currentOpenTelemetryHeaders, OpenInference, OpenInferenceSpanKind, ArvoExecution, ArvoExecutionSpanKind, ArvoContractJSONSchema, ArvoOrchestrationSubject, ArvoOrchestrationSubjectContent, ArvoSemanticVersion, InferArvoEvent, createArvoOrchestratorContract, ICreateArvoOrchestratorContract, ArvoOrchestratorEventTypeGen, ExecutionOpenTelemetryConfiguration, EventDataschemaUtil, ArvoOrchestrationSubjectContentSchema, ArvoSemanticVersionSchema, ArvoErrorSchema, ArvoErrorType, compareSemanticVersions, parseSemanticVersion, createSimpleArvoContract, ArvoOrchestratorContract, VersionedArvoContract, InferVersionedArvoContract, isWildCardArvoSematicVersion, WildCardArvoSemanticVersion, isValidArvoSemanticVersion, SimpleArvoContract, ArvoOrchestratorEventFactory, createArvoOrchestratorEventFactory, };

package/dist/index.js

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isValidArvoSemanticVersion = exports.WildCardArvoSemanticVersion = exports.isWildCardArvoSematicVersion = exports.VersionedArvoContract = exports.createSimpleArvoContract = exports.parseSemanticVersion = exports.compareSemanticVersions = exports.ArvoErrorSchema = exports.ArvoSemanticVersionSchema = exports.ArvoOrchestrationSubjectContentSchema = exports.EventDataschemaUtil = exports.ArvoOrchestratorEventTypeGen = exports.createArvoOrchestratorContract = exports.ArvoOrchestrationSubject = exports.ArvoExecutionSpanKind = exports.ArvoExecution = exports.OpenInferenceSpanKind = exports.OpenInference = exports.currentOpenTelemetryHeaders = exports.createArvoEventFactory = exports.ArvoEventFactory = exports.ArvoContractValidators = exports.createArvoContract = exports.ArvoContract = exports.cleanString = exports.validateURI = exports.OTelNull = exports.logToSpan = exports.exceptionToSpan = exports.ArvoEventSchema = exports.ArvoDataContentType = exports.createArvoEvent = exports.ArvoEvent = exports.ArvoEventHttp = void 0;
+exports.createArvoOrchestratorEventFactory = exports.ArvoOrchestratorEventFactory = exports.isValidArvoSemanticVersion = exports.WildCardArvoSemanticVersion = exports.isWildCardArvoSematicVersion = exports.VersionedArvoContract = exports.createSimpleArvoContract = exports.parseSemanticVersion = exports.compareSemanticVersions = exports.ArvoErrorSchema = exports.ArvoSemanticVersionSchema = exports.ArvoOrchestrationSubjectContentSchema = exports.EventDataschemaUtil = exports.ArvoOrchestratorEventTypeGen = exports.createArvoOrchestratorContract = exports.ArvoOrchestrationSubject = exports.ArvoExecutionSpanKind = exports.ArvoExecution = exports.OpenInferenceSpanKind = exports.OpenInference = exports.currentOpenTelemetryHeaders = exports.createArvoEventFactory = exports.ArvoEventFactory = exports.ArvoContractValidators = exports.createArvoContract = exports.ArvoContract = exports.cleanString = exports.validateURI = exports.OTelNull = exports.logToSpan = exports.exceptionToSpan = exports.ArvoEventSchema = exports.ArvoDataContentType = exports.createArvoEvent = exports.ArvoEvent = exports.ArvoEventHttp = void 0;
 var ArvoEvent_1 = __importDefault(require("./ArvoEvent"));
 exports.ArvoEvent = ArvoEvent_1.default;
 var schema_1 = require("./ArvoEvent/schema");
@@ -31,6 +31,7 @@ var ArvoEventFactory_1 = __importDefault(require("./ArvoEventFactory"));
 exports.ArvoEventFactory = ArvoEventFactory_1.default;
 var helpers_3 = require("./ArvoEventFactory/helpers");
 Object.defineProperty(exports, "createArvoEventFactory", { enumerable: true, get: function () { return helpers_3.createArvoEventFactory; } });
+Object.defineProperty(exports, "createArvoOrchestratorEventFactory", { enumerable: true, get: function () { return helpers_3.createArvoOrchestratorEventFactory; } });
 var schema_2 = require("./schema");
 Object.defineProperty(exports, "ArvoErrorSchema", { enumerable: true, get: function () { return schema_2.ArvoErrorSchema; } });
 Object.defineProperty(exports, "ArvoSemanticVersionSchema", { enumerable: true, get: function () { return schema_2.ArvoSemanticVersionSchema; } });
@@ -61,6 +62,8 @@ Object.defineProperty(exports, "isWildCardArvoSematicVersion", { enumerable: tru
 Object.defineProperty(exports, "WildCardArvoSemanticVersion", { enumerable: true, get: function () { return WildCardArvoSemanticVersion_1.WildCardArvoSemanticVersion; } });
 var SimpleArvoContract_1 = require("./ArvoContract/SimpleArvoContract");
 Object.defineProperty(exports, "createSimpleArvoContract", { enumerable: true, get: function () { return SimpleArvoContract_1.createSimpleArvoContract; } });
+var Orchestrator_1 = require("./ArvoEventFactory/Orchestrator");
+Object.defineProperty(exports, "ArvoOrchestratorEventFactory", { enumerable: true, get: function () { return Orchestrator_1.ArvoOrchestratorEventFactory; } });
 /**
  * Collection of Zod schemas for validating various aspects of Arvo events.
  * @property {z.ZodObject} CloudEventContextSchema - Schema for core CloudEvent properties.

package/dist/types.d.ts

@@ -58,15 +58,15 @@ export type ArvoErrorType = z.infer<typeof ArvoErrorSchema>;
  * @see {@link InferArvoEvent} for the event inference utility
  * @see {@link ArvoEvent} for the base event structure
  */
-export type InferVersionedArvoContract<TVersion extends VersionedArvoContract<any, any, any>> = {
+export type InferVersionedArvoContract<TVersion extends VersionedArvoContract<any, any>> = {
     accepts: InferArvoEvent<ArvoEvent<InferZodSchema<TVersion['accepts']['schema']>, {}, TVersion['accepts']['type']>>;
     systemError: InferArvoEvent<ArvoEvent<InferZodSchema<TVersion['systemError']['schema']>, {}, TVersion['systemError']['type']>>;
     emitMap: {
-        [K in string & keyof TVersion['emitMap']]: InferArvoEvent<ArvoEvent<InferZodSchema<TVersion['emitMap'][K]>, {}, K>>;
+        [K in string & keyof TVersion['emits']]: InferArvoEvent<ArvoEvent<InferZodSchema<TVersion['emits'][K]>, {}, K>>;
     };
     emits: Array<{
-        [K in string & keyof TVersion['emitMap']]: InferArvoEvent<ArvoEvent<InferZodSchema<TVersion['emitMap'][K]>, {}, K>>;
-    }[string & keyof TVersion['emitMap']]>;
+        [K in string & keyof TVersion['emits']]: InferArvoEvent<ArvoEvent<InferZodSchema<TVersion['emits'][K]>, {}, K>>;
+    }[string & keyof TVersion['emits']]>;
     metadata: TVersion['metadata'];
 };
 export {};

package/dist/utils.d.ts

@@ -1,4 +1,3 @@
-import ArvoContract from './ArvoContract';
 import { VersionedArvoContract } from './ArvoContract/VersionedArvoContract';
 import ArvoEvent from './ArvoEvent';
 import { ArvoSemanticVersion } from './types';
@@ -89,13 +88,13 @@ export declare class EventDataschemaUtil {
      * // Returns: "my-contract/1.0.0"
      * ```
      */
-    static create(contract: VersionedArvoContract<ArvoContract, ArvoSemanticVersion>): string;
+    static create(contract: VersionedArvoContract<any, any>): string;
     /**
      * Creates dataschema string with wildcard version.
      * @param contract Versioned contract
      * @returns `{contract.uri}/{WildCardArvoSemanticVersion}`
      */
-    static createWithWildCardVersion(contract: VersionedArvoContract<ArvoContract, ArvoSemanticVersion>): string;
+    static createWithWildCardVersion(contract: VersionedArvoContract<any, any>): string;
     /**
      * Extracts URI and version from dataschema string.
      *

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "arvo-core",
-  "version": "2.1.0",
+  "version": "2.1.2",
   "description": "This core package contains all the core classes and components of the Arvo Event Driven System",
   "main": "dist/index.js",
   "scripts": {