arvo-core 1.2.2 → 2.0.1

package/dist/ArvoOrchestratorContract/index.js

@@ -1,107 +1,113 @@
 "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 __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-var ArvoContract_1 = __importDefault(require("../ArvoContract"));
+exports.createArvoOrchestratorContract = void 0;
+var typegen_1 = require("./typegen");
+var schema_1 = require("./schema");
+var helpers_1 = require("../ArvoContract/helpers");
+/**
+ * Validates if a string contains only uppercase or lowercase alphanumeric characters.
+ *
+ * This function checks if the input string consists solely of:
+ * - Lowercase letters (a-z)
+ * - Numbers (0-9)
+ * - Dot (.)
+ *
+ * It does not allow any special characters, spaces, or other non-alphanumeric characters.
+ *
+ * @param input - The string to be validated.
+ * @returns True if the string contains only alphanumeric characters, false otherwise.
+ */
+function isLowerAlphanumeric(input) {
+    var alphanumericRegex = /^[a-z0-9.]+$/;
+    return alphanumericRegex.test(input);
+}
 /**
- * Defines the contract for the Arvo Orchestrator, specifying accepted events and emitted events.
+ * Creates an ArvoOrchestratorContract with specified parameters.
  *
- * The ArvoOrchestratorContract is a specialized contract class designed to manage the lifecycle
- * of orchestration processes within the Arvo framework. It extends the base ArvoContract class
- * to provide specific functionality for orchestration scenarios.
+ * The ArvoOrchestratorContract is a specialized contract designed to manage the lifecycle
+ * of orchestration processes within the Arvo framework. It creates a contract with an init event
+ * type and a corresponding complete event type.
  *
  * Key features:
- * 1. Initialization: Defines the structure and validation for the initial event that starts the orchestration.
- * 2. Completion: Specifies the event type and data emitted when the orchestration process concludes.
- * 3. Type Safety: Utilizes TypeScript generics to ensure type consistency across the contract definition.
- * 4. Runtime Validation: Employs Zod schemas for robust runtime type checking and data validation.
+ * 1. Type Validation: Ensures the type parameter follows lowercase alphanumeric with dots format
+ * 2. Event Type Generation: Automatically generates init and complete event types based on the provided type
+ * 3. Schema Merging: Merges provided init schemas with the OrchestrationInitEventBaseSchema
+ * 4. Version Support: Handles multiple versions of the contract with their respective schemas
  *
- * This contract serves as a crucial component in maintaining consistency and type safety
- * throughout the orchestration process, from initiation to completion.
+ * @template TUri - The URI type for the contract
+ * @template TType - The type identifier for the contract events
+ * @template TVersions - Record of versions with their corresponding init and complete schemas
+ *
+ * @param param - Configuration object for the orchestrator contract
+ * @param param.uri - The URI that uniquely identifies this contract
+ * @param param.type - The base type identifier (must be lowercase alphanumeric with dots)
+ * @param param.versions - Record of version configurations
+ * @param param.versions[version].init - Zod schema for initialization event (merged with OrchestrationInitEventBaseSchema)
+ * @param param.versions[version].complete - Zod schema for completion event
+ *
+ * @throws {Error} If the type parameter contains invalid characters (must be lowercase alphanumeric with dots)
+ *
+ * @returns An ArvoOrchestratorContract instance configured with the specified parameters
  *
  * @example
  * ```typescript
- * import { createArvoOrchestratorContract } from 'arvo-core'
- * import { z } from 'zod'
- *
  * const contract = createArvoOrchestratorContract({
- *  uri: '#/example/contract',
- *  name: 'rag',
- *  schema: {
- *    init: z.object({
- *      request: z.string()
- *      vectorStore: z.string(),
- *      llm: z.string()
- *    }),
- *    complete: z.object({
- *      response: z.string()
- *    })
- *  }
- * })
+ *   uri: '#/orchestrators/data/processor',
+ *   type: 'data.processor',
+ *   versions: {
+ *     '1.0.0': {
+ *       init: z.object({
+ *         data: z.string(),
+ *         options: z.object({
+ *           format: z.string()
+ *         })
+ *       }),
+ *       complete: z.object({
+ *         processedData: z.string(),
+ *         metadata: z.record(z.string())
+ *       })
+ *     },
+ *     '1.1.0': {
+ *       init: z.object({
+ *         data: z.string(),
+ *         options: z.object({
+ *           format: z.string(),
+ *           compression: z.boolean().optional()
+ *         })
+ *       }),
+ *       complete: z.object({
+ *         processedData: z.string(),
+ *         metadata: z.record(z.string()),
+ *         performance: z.object({
+ *           duration: z.number(),
+ *           bytesProcessed: z.number()
+ *         })
+ *       })
+ *     }
+ *   }
+ * });
  * ```
  */
-var ArvoOrchestratorContract = /** @class */ (function (_super) {
-    __extends(ArvoOrchestratorContract, _super);
-    /**
-     * Constructs a new ArvoOrchestratorContract instance.
-     *
-     * @param param - The configuration object for the contract.
-     */
-    function ArvoOrchestratorContract(param) {
-        var _a;
-        return _super.call(this, {
-            uri: param.uri,
-            accepts: param.init,
-            // @ts-ignore
-            emits: (_a = {},
-                _a[param.complete.type] = param.complete.schema,
-                _a),
-        }) || this;
+var createArvoOrchestratorContract = function (param) {
+    if (!isLowerAlphanumeric(param.type)) {
+        throw new Error("Invalid 'type' = '".concat(param.type, "'. The 'type' must only contain alphanumeric characters. e.g. test.orchestrator"));
     }
-    Object.defineProperty(ArvoOrchestratorContract.prototype, "init", {
-        /**
-         * Gets the initialization event configuration.
-         *
-         * @returns An object containing the type and schema for the initialization event.
-         */
-        get: function () {
-            return this.accepts;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(ArvoOrchestratorContract.prototype, "complete", {
-        /**
-         * Gets the completion event configuration.
-         *
-         * @returns An object containing the type and schema for the completion event.
-         */
-        get: function () {
-            var _a = Object.entries(this.emits)[0], type = _a[0], schema = _a[1];
-            return {
-                type: type,
-                schema: schema,
-            };
-        },
-        enumerable: false,
-        configurable: true
-    });
-    return ArvoOrchestratorContract;
-}(ArvoContract_1.default));
-exports.default = ArvoOrchestratorContract;
+    return (0, helpers_1.createArvoContract)({
+        uri: param.uri,
+        type: typegen_1.ArvoOrchestratorEventTypeGen.init(param.type),
+        versions: Object.fromEntries(Object.entries(param.versions).map(function (_a) {
+            var _b;
+            var version = _a[0], contract = _a[1];
+            return [
+                version,
+                {
+                    accepts: schema_1.OrchestrationInitEventBaseSchema.merge(contract.init),
+                    emits: (_b = {},
+                        _b[typegen_1.ArvoOrchestratorEventTypeGen.complete(param.type)] = contract.complete,
+                        _b),
+                },
+            ];
+        })),
+    }, true);
+};
+exports.createArvoOrchestratorContract = createArvoOrchestratorContract;

package/dist/ArvoOrchestratorContract/types.d.ts

@@ -1,85 +1,78 @@
 import { z } from 'zod';
+import { ArvoSemanticVersion } from '../types';
+import ArvoContract from '../ArvoContract';
+import { ArvoOrchestratorEventTypeGen } from './typegen';
+import { OrchestrationInitEventBaseSchema } from './schema';
 /**
- * Represents the configuration interface for an Arvo Orchestrator Contract.
+ * Represents an Arvo Orchestrator Contract type that extends the base ArvoContract.
+ * This type specifically handles orchestration flows with initialization and completion events.
  *
- * This interface defines the structure of the configuration object used to initialize
- * an ArvoOrchestratorContract. It specifies the types and schemas for both the
- * initialization event and the completion event of the orchestration process.
+ * @template TUri - The URI type that uniquely identifies the contract
+ * @template TType - The base event type for the orchestrator
+ * @template TVersions - Record of versioned schemas for init and complete events
  *
- * @template TUri - The type for the URI string that uniquely identifies the contract.
- * @template TInitType - The literal type for the initialization event type.
- * @template TInit - The Zod schema type for validating the initialization event data.
- * @template TCompleteType - The literal type for the completion event type.
- * @template TComplete - The Zod schema type for validating the completion event data.
+ * @example
+ * ```typescript
+ * type MyOrchestrator = ArvoOrchestratorContract<
+ *   '/orchestrators/payment-flow',
+ *   'payment.process',
+ *   {
+ *     '1.0.0': {
+ *       init: z.object({ amount: z.number() }),
+ *       complete: z.object({ transactionId: z.string() })
+ *     }
+ *   }
+ * >;
+ * ```
+ *
+ * @remarks
+ * - The contract automatically generates appropriate event types for init and complete events
+ * - Each version must specify both init and complete schemas
+ * - Event types are generated using the ArvoOrchestratorEventTypeGen utility
  */
-export interface IArvoOrchestratorContract<TUri extends string, TInitType extends string, TInit extends z.ZodTypeAny, TCompleteType extends string, TComplete extends z.ZodTypeAny> {
-    /**
-     * The unique identifier for the contract.
-     */
-    uri: TUri;
-    /**
-     * Configuration for the initialization event.
-     */
-    init: {
-        /**
-         * The type identifier for the initialization event.
-         */
-        type: TInitType;
-        /**
-         * The Zod schema used to validate the initialization event data.
-         */
-        schema: TInit;
-    };
-    /**
-     * Configuration for the completion event.
-     */
-    complete: {
-        /**
-         * The type identifier for the completion event.
-         */
-        type: TCompleteType;
-        /**
-         * The Zod schema used to validate the completion event data.
-         */
-        schema: TComplete;
+export type ArvoOrchestratorContract<TUri extends string = string, TType extends string = string, TVersions extends Record<ArvoSemanticVersion, {
+    init: z.ZodObject<any, any, any>;
+    complete: z.ZodObject<any, any, any>;
+}> = Record<ArvoSemanticVersion, {
+    init: z.ZodObject<any, any, any>;
+    complete: z.ZodObject<any, any, any>;
+}>> = ArvoContract<TUri, ReturnType<typeof ArvoOrchestratorEventTypeGen.init<TType>>, {
+    [V in ArvoSemanticVersion & keyof TVersions]: {
+        accepts: ReturnType<typeof OrchestrationInitEventBaseSchema.merge<TVersions[V]['init'], TVersions[V]['init']['shape']>>;
+        emits: {
+            [K in ReturnType<typeof ArvoOrchestratorEventTypeGen.complete<TType>>]: TVersions[V]['complete'];
+        };
     };
-}
+}>;
 /**
- * Interface for creating an Arvo Orchestrator Contract.
+ * Interface defining the configuration structure for creating an Arvo Orchestrator Contract.
+ * This interface specifies the required properties for initializing a new orchestrator contract.
  *
- * This interface defines the structure of the configuration object used to create
- * an ArvoOrchestratorContract. It specifies the URI, name, and schemas for both
- * the initialization and completion events of the orchestration process.
+ * @template TUri - The URI type that uniquely identifies the contract
+ * @template TType - The base event type for the orchestrator
+ * @template TVersions - Record of versioned schemas for init and complete events
  *
- * @template TUri - The type for the URI string that uniquely identifies the contract.
- * @template TName - The type for the name of the contract.
- * @template TInit - The Zod schema type for validating the initialization event data.
- * @template TComplete - The Zod schema type for validating the completion event data.
+ * @property uri - The unique identifier URI for the contract
+ * @property type - The base event type that will be used to generate init/complete event types
+ * @property versions - A record of version-specific schemas for initialization and completion events
+ *
+ * @remarks
+ * - The URI should be unique within your system
+ * - The type will be used to generate appropriate event type strings
+ * - Each version must conform to {@link ArvoSemanticVersion} format
+ * - Init and complete schemas should use Zod for validation
  */
-export interface ICreateArvoOrchestratorContract<TUri extends string, TName extends string, TInit extends z.ZodTypeAny, TComplete extends z.ZodTypeAny> {
-    /**
-     * The unique identifier for the contract.
-     * This URI should be used to reference the contract within the system.
-     */
+export interface ICreateArvoOrchestratorContract<TUri extends string, TType extends string, TVersions extends Record<ArvoSemanticVersion, {
+    init: z.ZodTypeAny;
+    complete: z.ZodTypeAny;
+}>> {
+    /** Unique identifier URI for the contract */
     uri: TUri;
+    /** Base event type used for generating init/complete event types */
+    type: TType;
     /**
-     * The name of the contract.
-     * This can be used for display purposes or for easier identification of the contract.
-     */
-    name: TName;
-    /**
-     * The schema definitions for the contract events.
+     * Version-specific schemas for initialization and completion events
+     * @remarks Each version must provide both init and complete schemas
      */
-    schema: {
-        /**
-         * The Zod schema used to validate the initialization event data.
-         * This schema defines the structure and types of the data required to start the orchestration process.
-         */
-        init: TInit;
-        /**
-         * The Zod schema used to validate the completion event data.
-         * This schema defines the structure and types of the data emitted when the orchestration process completes.
-         */
-        complete: TComplete;
-    };
+    versions: TVersions;
 }

package/dist/index.d.ts

@@ -3,32 +3,28 @@ import { ArvoDataContentType } from './ArvoEvent/schema';
 import { createArvoEvent } from './ArvoEvent/helpers';
 import { CloudEventContext, CloudEventExtension, ArvoEventData, ArvoExtension, OpenTelemetryExtension, CreateArvoEvent } from './ArvoEvent/types';
 import { exceptionToSpan, logToSpan, OTelNull, currentOpenTelemetryHeaders } from './OpenTelemetry';
-import { OpenTelemetryHeaders, TelemetryLogLevel } from './OpenTelemetry/types';
-import { validateURI, cleanString } from './utils';
+import { OpenTelemetryHeaders, TelemetryLogLevel, ExecutionOpenTelemetryConfiguration } from './OpenTelemetry/types';
+import { validateURI, cleanString, compareSemanticVersions, parseSemanticVersion } from './utils';
 import ArvoContract from './ArvoContract';
-import { createArvoContract, InferArvoContract as InferArvoContractType } from './ArvoContract/helpers';
+import { createArvoContract, createSimpleArvoContract } from './ArvoContract/helpers';
 import { ArvoContractValidators } from './ArvoContract/validators';
 import { ArvoContractRecord, IArvoContract, ResolveArvoContractRecord, ArvoContractJSONSchema } from './ArvoContract/types';
-import ArvoContractLibrary from './ArvoContractLibrary';
-import { createArvoContractLibrary } from './ArvoContractLibrary/helpers';
 import ArvoEventFactory from './ArvoEventFactory';
-import { createArvoEventFactory } from './ArvoEventFactory/helpers';
-import { ArvoErrorSchema } from './schema';
+import { createArvoEventFactory, parseEventDataSchema } from './ArvoEventFactory/helpers';
+import { ArvoErrorSchema, ArvoSemanticVersionSchema } from './schema';
 import OpenInference from './OpenTelemetry/OpenInference';
 import ArvoExecution from './OpenTelemetry/ArvoExecution';
 import { ArvoExecutionSpanKind } from './OpenTelemetry/ArvoExecution/types';
 import { OpenInferenceSpanKind } from './OpenTelemetry/OpenInference/types';
 import ArvoOrchestrationSubject from './ArvoOrchestrationSubject';
-import { ArvoOrchestrationSubjectContentSchema, ArvoOrchestratorVersionSchema } from './ArvoOrchestrationSubject/schema';
-import { ArvoOrchestrationSubjectContent, ArvoOrchestratorVersion } from './ArvoOrchestrationSubject/type';
+import { ArvoOrchestrationSubjectContentSchema } from './ArvoOrchestrationSubject/schema';
+import { ArvoOrchestrationSubjectContent } from './ArvoOrchestrationSubject/type';
 import ArvoEventHttp from './ArvoEventHttp';
 import { ArvoEventHttpConfig } from './ArvoEventHttp/types';
-import { InferArvoContract, InferArvoEvent, InferArvoOrchestratorContract } from './types';
-import { createArvoOrchestratorContract } from './ArvoOrchestratorContract/helpers';
-import ArvoOrchestratorContract from './ArvoOrchestratorContract';
-import { ICreateArvoOrchestratorContract, IArvoOrchestratorContract } from './ArvoOrchestratorContract/types';
+import { InferArvoContract, InferArvoEvent, ArvoSemanticVersion, ArvoErrorType } from './types';
+import { createArvoOrchestratorContract } from './ArvoOrchestratorContract';
+import { ICreateArvoOrchestratorContract } from './ArvoOrchestratorContract/types';
 import { ArvoOrchestratorEventTypeGen } from './ArvoOrchestratorContract/typegen';
-import { ExecutionOpenTelemetryConfiguration } from './OpenTelemetry/types';
 /**
  * Collection of Zod schemas for validating various aspects of Arvo events.
  * @property {z.ZodObject} CloudEventContextSchema - Schema for core CloudEvent properties.
@@ -38,7 +34,7 @@ import { ExecutionOpenTelemetryConfiguration } from './OpenTelemetry/types';
  * @property {z.ZodObject} OpenTelemetryExtensionSchema - Schema for OpenTelemetry extensions.
  * @property {z.ZodObject} OrchestrationInitEventBaseSchema - The base schema for the orchestrator init events.
  */
-declare const ArvoEventSchemas: {
+declare const ArvoEventSchema: {
     CloudEventContextSchema: import("zod").ZodObject<{
         id: import("zod").ZodString;
         time: import("zod").ZodString;
@@ -49,20 +45,20 @@ declare const ArvoEventSchemas: {
         datacontenttype: import("zod").ZodDefault<import("zod").ZodEffects<import("zod").ZodString, string, string>>;
         dataschema: import("zod").ZodNullable<import("zod").ZodEffects<import("zod").ZodString, string, string>>;
     }, "strip", import("zod").ZodTypeAny, {
+        type: string;
         id: string;
         time: string;
         source: string;
         specversion: "1.0";
-        type: string;
         subject: string;
         datacontenttype: string;
         dataschema: string | null;
     }, {
+        type: string;
         id: string;
         time: string;
         source: string;
         specversion: string;
-        type: string;
         subject: string;
         dataschema: string | null;
         datacontenttype?: string | undefined;
@@ -103,4 +99,4 @@ declare const ArvoEventSchemas: {
         parentSubject$$: string | null;
     }>;
 };
-export { ArvoEventHttpConfig, ArvoEventHttp, ArvoEvent, createArvoEvent, ArvoDataContentType, ArvoEventData, CloudEventExtension, ArvoEventSchemas, CloudEventContext, ArvoExtension, OpenTelemetryExtension, CreateArvoEvent, exceptionToSpan, logToSpan, OpenTelemetryHeaders, TelemetryLogLevel, OTelNull, validateURI, cleanString, ArvoContract, createArvoContract, ArvoContractValidators, ArvoContractRecord, IArvoContract, ResolveArvoContractRecord, ArvoContractLibrary, createArvoContractLibrary, ArvoEventFactory, createArvoEventFactory, ArvoErrorSchema, currentOpenTelemetryHeaders, OpenInference, OpenInferenceSpanKind, ArvoExecution, ArvoExecutionSpanKind, ArvoContractJSONSchema, ArvoOrchestrationSubject, ArvoOrchestrationSubjectContentSchema, ArvoOrchestratorVersionSchema, ArvoOrchestrationSubjectContent, ArvoOrchestratorVersion, InferArvoEvent, InferArvoContract, InferArvoContractType, createArvoOrchestratorContract, ArvoOrchestratorContract, ICreateArvoOrchestratorContract, IArvoOrchestratorContract, InferArvoOrchestratorContract, ArvoOrchestratorEventTypeGen, ExecutionOpenTelemetryConfiguration, };
+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, InferArvoContract, createArvoOrchestratorContract, ICreateArvoOrchestratorContract, ArvoOrchestratorEventTypeGen, ExecutionOpenTelemetryConfiguration, parseEventDataSchema, ArvoOrchestrationSubjectContentSchema, ArvoSemanticVersionSchema, ArvoErrorSchema, ArvoErrorType, compareSemanticVersions, parseSemanticVersion, createSimpleArvoContract, };

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.ArvoOrchestratorEventTypeGen = exports.ArvoOrchestratorContract = exports.createArvoOrchestratorContract = exports.ArvoOrchestratorVersionSchema = exports.ArvoOrchestrationSubjectContentSchema = exports.ArvoOrchestrationSubject = exports.ArvoExecutionSpanKind = exports.ArvoExecution = exports.OpenInferenceSpanKind = exports.OpenInference = exports.currentOpenTelemetryHeaders = exports.ArvoErrorSchema = exports.createArvoEventFactory = exports.ArvoEventFactory = exports.createArvoContractLibrary = exports.ArvoContractLibrary = exports.ArvoContractValidators = exports.createArvoContract = exports.ArvoContract = exports.cleanString = exports.validateURI = exports.OTelNull = exports.logToSpan = exports.exceptionToSpan = exports.ArvoEventSchemas = exports.ArvoDataContentType = exports.createArvoEvent = exports.ArvoEvent = exports.ArvoEventHttp = void 0;
+exports.createSimpleArvoContract = exports.parseSemanticVersion = exports.compareSemanticVersions = exports.ArvoErrorSchema = exports.ArvoSemanticVersionSchema = exports.ArvoOrchestrationSubjectContentSchema = exports.parseEventDataSchema = 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");
@@ -18,22 +18,23 @@ Object.defineProperty(exports, "currentOpenTelemetryHeaders", { enumerable: true
 var utils_1 = require("./utils");
 Object.defineProperty(exports, "validateURI", { enumerable: true, get: function () { return utils_1.validateURI; } });
 Object.defineProperty(exports, "cleanString", { enumerable: true, get: function () { return utils_1.cleanString; } });
+Object.defineProperty(exports, "compareSemanticVersions", { enumerable: true, get: function () { return utils_1.compareSemanticVersions; } });
+Object.defineProperty(exports, "parseSemanticVersion", { enumerable: true, get: function () { return utils_1.parseSemanticVersion; } });
 var ArvoContract_1 = __importDefault(require("./ArvoContract"));
 exports.ArvoContract = ArvoContract_1.default;
 var helpers_2 = require("./ArvoContract/helpers");
 Object.defineProperty(exports, "createArvoContract", { enumerable: true, get: function () { return helpers_2.createArvoContract; } });
+Object.defineProperty(exports, "createSimpleArvoContract", { enumerable: true, get: function () { return helpers_2.createSimpleArvoContract; } });
 var validators_1 = require("./ArvoContract/validators");
 Object.defineProperty(exports, "ArvoContractValidators", { enumerable: true, get: function () { return validators_1.ArvoContractValidators; } });
-var ArvoContractLibrary_1 = __importDefault(require("./ArvoContractLibrary"));
-exports.ArvoContractLibrary = ArvoContractLibrary_1.default;
-var helpers_3 = require("./ArvoContractLibrary/helpers");
-Object.defineProperty(exports, "createArvoContractLibrary", { enumerable: true, get: function () { return helpers_3.createArvoContractLibrary; } });
 var ArvoEventFactory_1 = __importDefault(require("./ArvoEventFactory"));
 exports.ArvoEventFactory = ArvoEventFactory_1.default;
-var helpers_4 = require("./ArvoEventFactory/helpers");
-Object.defineProperty(exports, "createArvoEventFactory", { enumerable: true, get: function () { return helpers_4.createArvoEventFactory; } });
+var helpers_3 = require("./ArvoEventFactory/helpers");
+Object.defineProperty(exports, "createArvoEventFactory", { enumerable: true, get: function () { return helpers_3.createArvoEventFactory; } });
+Object.defineProperty(exports, "parseEventDataSchema", { enumerable: true, get: function () { return helpers_3.parseEventDataSchema; } });
 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; } });
 var OpenInference_1 = __importDefault(require("./OpenTelemetry/OpenInference"));
 exports.OpenInference = OpenInference_1.default;
 var ArvoExecution_1 = __importDefault(require("./OpenTelemetry/ArvoExecution"));
@@ -46,13 +47,10 @@ var ArvoOrchestrationSubject_1 = __importDefault(require("./ArvoOrchestrationSub
 exports.ArvoOrchestrationSubject = ArvoOrchestrationSubject_1.default;
 var schema_3 = require("./ArvoOrchestrationSubject/schema");
 Object.defineProperty(exports, "ArvoOrchestrationSubjectContentSchema", { enumerable: true, get: function () { return schema_3.ArvoOrchestrationSubjectContentSchema; } });
-Object.defineProperty(exports, "ArvoOrchestratorVersionSchema", { enumerable: true, get: function () { return schema_3.ArvoOrchestratorVersionSchema; } });
 var ArvoEventHttp_1 = __importDefault(require("./ArvoEventHttp"));
 exports.ArvoEventHttp = ArvoEventHttp_1.default;
-var helpers_5 = require("./ArvoOrchestratorContract/helpers");
-Object.defineProperty(exports, "createArvoOrchestratorContract", { enumerable: true, get: function () { return helpers_5.createArvoOrchestratorContract; } });
-var ArvoOrchestratorContract_1 = __importDefault(require("./ArvoOrchestratorContract"));
-exports.ArvoOrchestratorContract = ArvoOrchestratorContract_1.default;
+var ArvoOrchestratorContract_1 = require("./ArvoOrchestratorContract");
+Object.defineProperty(exports, "createArvoOrchestratorContract", { enumerable: true, get: function () { return ArvoOrchestratorContract_1.createArvoOrchestratorContract; } });
 var typegen_1 = require("./ArvoOrchestratorContract/typegen");
 Object.defineProperty(exports, "ArvoOrchestratorEventTypeGen", { enumerable: true, get: function () { return typegen_1.ArvoOrchestratorEventTypeGen; } });
 var schema_4 = require("./ArvoOrchestratorContract/schema");
@@ -65,7 +63,7 @@ var schema_4 = require("./ArvoOrchestratorContract/schema");
  * @property {z.ZodObject} OpenTelemetryExtensionSchema - Schema for OpenTelemetry extensions.
  * @property {z.ZodObject} OrchestrationInitEventBaseSchema - The base schema for the orchestrator init events.
  */
-var ArvoEventSchemas = {
+var ArvoEventSchema = {
     CloudEventContextSchema: schema_1.CloudEventContextSchema,
     CloudEventExtensionSchema: schema_1.CloudEventExtensionSchema,
     ArvoDataSchema: schema_1.ArvoDataSchema,
@@ -73,4 +71,4 @@ var ArvoEventSchemas = {
     OpenTelemetryExtensionSchema: schema_1.OpenTelemetryExtensionSchema,
     OrchestrationInitEventBaseSchema: schema_4.OrchestrationInitEventBaseSchema,
 };
-exports.ArvoEventSchemas = ArvoEventSchemas;
+exports.ArvoEventSchema = ArvoEventSchema;

package/dist/schema.d.ts

@@ -18,3 +18,4 @@ export declare const ArvoErrorSchema: z.ZodObject<{
     errorName: string;
     errorStack: string | null;
 }>;
+export declare const ArvoSemanticVersionSchema: z.ZodString;

package/dist/schema.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ArvoErrorSchema = void 0;
+exports.ArvoSemanticVersionSchema = exports.ArvoErrorSchema = void 0;
 var zod_1 = require("zod");
 /**
  * Schema for Arvo error objects.
@@ -13,3 +13,8 @@ exports.ArvoErrorSchema = zod_1.z.object({
     errorMessage: zod_1.z.string().describe('A descriptive message for the error.'),
     errorStack: zod_1.z.string().nullable().describe('The stack trace of the error.'),
 });
+// Zod schema for ArvoSemanticVersion
+exports.ArvoSemanticVersionSchema = zod_1.z
+    .string()
+    .regex(/^\d+\.\d+\.\d+$/, 'Invalid version format of the semantic version')
+    .describe('Semantic version of the Arvo component in the format X.Y.Z');