arvo-core 2.0.10 → 2.1.0

package/dist/ArvoOrchestrationSubject/index.js

@@ -38,6 +38,7 @@ var schema_1 = require("./schema");
 var zlib = __importStar(require("node:zlib"));
 var utils_1 = require("../utils");
 var uuid_1 = require("uuid");
+var WildCardArvoSemanticVersion_1 = require("../ArvoContract/WildCardArvoSemanticVersion");
 /**
  * Handles the creation and parsing of Arvo orchestration subjects.
  */
@@ -50,7 +51,7 @@ var ArvoOrchestrationSubject = /** @class */ (function () {
      *
      * @param param - Configuration object for the orchestration subject
      * @param param.orchestator - Name identifier of the orchestrator
-     * @param param.version - Version of the orchestrator. If null, defaults to {@link WildCardMachineVersion}
+     * @param param.version - Version of the orchestrator. If null, defaults to {@link WildCardArvoSemanticVersion}
      * @param param.initiator - Identifier of the entity initiating the orchestration
      * @param param.meta - Optional metadata key-value pairs for additional orchestration context
      * @returns A base64 encoded string containing the compressed orchestration subject data
@@ -81,7 +82,7 @@ var ArvoOrchestrationSubject = /** @class */ (function () {
         return ArvoOrchestrationSubject.create({
             orchestrator: {
                 name: param.orchestator,
-                version: (_a = param.version) !== null && _a !== void 0 ? _a : ArvoOrchestrationSubject.WildCardMachineVersion,
+                version: (_a = param.version) !== null && _a !== void 0 ? _a : WildCardArvoSemanticVersion_1.WildCardArvoSemanticVersion,
             },
             execution: {
                 id: (0, uuid_1.v4)(),
@@ -98,7 +99,7 @@ var ArvoOrchestrationSubject = /** @class */ (function () {
      *
      * @param param - Configuration object for creating a new subject from a parent
      * @param param.orchestator - Name identifier of the new orchestrator
-     * @param param.version - Version of the new orchestrator. If null, defaults to {@link WildCardMachineVersion}
+     * @param param.version - Version of the new orchestrator. If null, defaults to {@link WildCardArvoSemanticVersion}
      * @param param.subject - Base64 encoded string of the parent orchestration subject
      * @param param.meta - Optional additional metadata to merge with the parent's metadata
      * @returns A new base64 encoded string containing the compressed orchestration subject data
@@ -128,7 +129,7 @@ var ArvoOrchestrationSubject = /** @class */ (function () {
         var parsedSubject = ArvoOrchestrationSubject.parse(param.subject);
         return ArvoOrchestrationSubject.new({
             initiator: parsedSubject.orchestrator.name,
-            version: (_a = param.version) !== null && _a !== void 0 ? _a : ArvoOrchestrationSubject.WildCardMachineVersion,
+            version: (_a = param.version) !== null && _a !== void 0 ? _a : WildCardArvoSemanticVersion_1.WildCardArvoSemanticVersion,
             orchestator: param.orchestator,
             meta: __assign(__assign({}, ((_b = parsedSubject.meta) !== null && _b !== void 0 ? _b : {})), ((_c = param.meta) !== null && _c !== void 0 ? _c : {})),
         });
@@ -199,11 +200,6 @@ var ArvoOrchestrationSubject = /** @class */ (function () {
             throw new Error((0, utils_1.cleanString)("\n        Error parsing orchestration subject string to the context. \n        Error -> ".concat(e.message, "  \n        subject -> ").concat(subject, "\n      ")));
         }
     };
-    /**
-     * Represents a wildcard version number used when version matching is not required.
-     * Format follows semantic versioning pattern.
-     */
-    ArvoOrchestrationSubject.WildCardMachineVersion = '0.0.0';
     return ArvoOrchestrationSubject;
 }());
 exports.default = ArvoOrchestrationSubject;

package/dist/ArvoOrchestrationSubject/schema.d.ts

@@ -4,11 +4,11 @@ export declare const ArvoOrchestrationSubjectContentSchema: z.ZodObject<{
         name: z.ZodEffects<z.ZodString, string, string>;
         version: z.ZodString;
     }, "strip", z.ZodTypeAny, {
-        name: string;
         version: string;
-    }, {
         name: string;
+    }, {
         version: string;
+        name: string;
     }>;
     execution: z.ZodObject<{
         id: z.ZodEffects<z.ZodString, string, string>;
@@ -23,8 +23,8 @@ export declare const ArvoOrchestrationSubjectContentSchema: z.ZodObject<{
     meta: z.ZodRecord<z.ZodString, z.ZodString>;
 }, "strip", z.ZodTypeAny, {
     orchestrator: {
-        name: string;
         version: string;
+        name: string;
     };
     execution: {
         id: string;
@@ -33,8 +33,8 @@ export declare const ArvoOrchestrationSubjectContentSchema: z.ZodObject<{
     meta: Record<string, string>;
 }, {
     orchestrator: {
-        name: string;
         version: string;
+        name: string;
     };
     execution: {
         id: string;

package/dist/ArvoOrchestratorContract/index.d.ts

@@ -14,16 +14,7 @@ import { ArvoSemanticVersion } from '../types';
  * 3. Schema Merging: Merges provided init schemas with the OrchestrationInitEventBaseSchema
  * 4. Version Support: Handles multiple versions of the contract with their respective schemas
  *
- * @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
+ * @param contract - Configuration object for the orchestrator contract
  *
  * @throws {Error} If the type parameter contains invalid characters (must be lowercase alphanumeric with dots)
  *
@@ -33,7 +24,7 @@ import { ArvoSemanticVersion } from '../types';
  * ```typescript
  * const contract = createArvoOrchestratorContract({
  *   uri: '#/orchestrators/data/processor',
- *   type: 'data.processor',
+ *   name: 'data.processor',
  *   versions: {
  *     '1.0.0': {
  *       init: z.object({
@@ -68,7 +59,7 @@ import { ArvoSemanticVersion } from '../types';
  * });
  * ```
  */
-export declare const createArvoOrchestratorContract: <TUri extends string, TType extends string, TVersions extends Record<ArvoSemanticVersion, {
+export declare const createArvoOrchestratorContract: <TUri extends string, TName extends string, TVersions extends Record<ArvoSemanticVersion, {
     init: z.ZodObject<any, any, any>;
     complete: z.ZodObject<any, any, any>;
-}>>(param: ICreateArvoOrchestratorContract<TUri, TType, TVersions>) => ArvoOrchestratorContract<TUri, TType, TVersions>;
+}>, TMetaData extends Record<string, any>>(contract: ICreateArvoOrchestratorContract<TUri, TName, TVersions, TMetaData>) => ArvoOrchestratorContract<TUri, TName, TVersions, TMetaData>;

package/dist/ArvoOrchestratorContract/index.js

@@ -1,9 +1,23 @@
 "use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createArvoOrchestratorContract = void 0;
 var typegen_1 = require("./typegen");
 var schema_1 = require("./schema");
-var helpers_1 = require("../ArvoContract/helpers");
+var ArvoContract_1 = __importDefault(require("../ArvoContract"));
 /**
  * Validates if a string contains only uppercase or lowercase alphanumeric characters.
  *
@@ -34,16 +48,7 @@ function isLowerAlphanumeric(input) {
  * 3. Schema Merging: Merges provided init schemas with the OrchestrationInitEventBaseSchema
  * 4. Version Support: Handles multiple versions of the contract with their respective schemas
  *
- * @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
+ * @param contract - Configuration object for the orchestrator contract
  *
  * @throws {Error} If the type parameter contains invalid characters (must be lowercase alphanumeric with dots)
  *
@@ -53,7 +58,7 @@ function isLowerAlphanumeric(input) {
  * ```typescript
  * const contract = createArvoOrchestratorContract({
  *   uri: '#/orchestrators/data/processor',
- *   type: 'data.processor',
+ *   name: 'data.processor',
  *   versions: {
  *     '1.0.0': {
  *       init: z.object({
@@ -88,26 +93,30 @@ function isLowerAlphanumeric(input) {
  * });
  * ```
  */
-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"));
+var createArvoOrchestratorContract = function (contract) {
+    var _a, _b;
+    if (!isLowerAlphanumeric(contract.name)) {
+        throw new Error("Invalid 'name' = '".concat(contract.name, "'. The 'name' must only contain alphanumeric characters. e.g. test.orchestrator"));
     }
-    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 mergedMetaData = __assign(__assign({}, ((_a = contract.metadata) !== null && _a !== void 0 ? _a : {})), { contractType: 'ArvoOrchestratorContract', rootType: contract.name, completeEventType: typegen_1.ArvoOrchestratorEventTypeGen.complete(contract.name), initEventType: typegen_1.ArvoOrchestratorEventTypeGen.init(contract.name) });
+    return new ArvoContract_1.default({
+        uri: contract.uri,
+        type: typegen_1.ArvoOrchestratorEventTypeGen.init(contract.name),
+        description: (_b = contract.description) !== null && _b !== void 0 ? _b : null,
+        metadata: mergedMetaData,
+        versions: Object.fromEntries(Object.entries(contract.versions).map(function (_a) {
             var _b;
-            var version = _a[0], contract = _a[1];
+            var version = _a[0], versionContract = _a[1];
             return [
                 version,
                 {
-                    accepts: schema_1.OrchestrationInitEventBaseSchema.merge(contract.init),
+                    accepts: schema_1.OrchestrationInitEventBaseSchema.merge(versionContract.init),
                     emits: (_b = {},
-                        _b[typegen_1.ArvoOrchestratorEventTypeGen.complete(param.type)] = contract.complete,
+                        _b[typegen_1.ArvoOrchestratorEventTypeGen.complete(contract.name)] = versionContract.complete,
                         _b),
                 },
             ];
         })),
-    }, true);
+    });
 };
 exports.createArvoOrchestratorContract = createArvoOrchestratorContract;

package/dist/ArvoOrchestratorContract/typegen.d.ts

@@ -17,6 +17,14 @@ export declare class ArvoOrchestratorEventTypeGen {
      * This prefix helps identify events that belong to the Arvo orchestrator system.
      */
     static readonly prefix: 'arvo.orc';
+    /**
+     * Checks if an event type belongs to the Arvo orchestrator.
+     *
+     * @param eventType - Event type string to check
+     * @returns True if the event is an orchestrator event, false otherwise
+     * ```
+     */
+    static isOrchestratorEventType(eventType: string): boolean;
     /**
      * Generates an initialization event type string for a given event name.
      *

package/dist/ArvoOrchestratorContract/typegen.js

@@ -17,6 +17,16 @@ exports.ArvoOrchestratorEventTypeGen = void 0;
 var ArvoOrchestratorEventTypeGen = /** @class */ (function () {
     function ArvoOrchestratorEventTypeGen() {
     }
+    /**
+     * Checks if an event type belongs to the Arvo orchestrator.
+     *
+     * @param eventType - Event type string to check
+     * @returns True if the event is an orchestrator event, false otherwise
+     * ```
+     */
+    ArvoOrchestratorEventTypeGen.isOrchestratorEventType = function (eventType) {
+        return eventType.startsWith(ArvoOrchestratorEventTypeGen.prefix);
+    };
     /**
      * Generates an initialization event type string for a given event name.
      *

package/dist/ArvoOrchestratorContract/types.d.ts

@@ -4,45 +4,40 @@ import ArvoContract from '../ArvoContract';
 import { ArvoOrchestratorEventTypeGen } from './typegen';
 import { OrchestrationInitEventBaseSchema } from './schema';
 /**
- * Represents an Arvo Orchestrator Contract type that extends the base ArvoContract.
- * This type specifically handles orchestration flows with initialization and completion events.
+ * A specialized ArvoContract type for orchestrating complex event flows.
+ * Automatically generates appropriately typed init and complete events.
  *
- * @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
- *
- * @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() })
- *     }
- *   }
- * >;
- * ```
+ * @template TUri - Unique contract identifier URI
+ * @template TName - Base name for generating orchestrator event types
+ * @template TVersions - Version-specific schemas for init and complete events
+ * @template TMetaData - Additional metadata type (optional)
  *
  * @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
+ * Key characteristics:
+ * - Automatically generates init and complete event types using {@link ArvoOrchestratorEventTypeGen}
+ * - Enforces schema definitions for both initialization and completion events
+ * - Maintains version compatibility with {@link ArvoSemanticVersion}
+ * - Includes metadata about contract type and event types
+ * - Merges initialization schemas with base orchestration schema
  */
-export type ArvoOrchestratorContract<TUri extends string = string, TType extends string = string, TVersions extends Record<ArvoSemanticVersion, {
+export type ArvoOrchestratorContract<TUri extends string = string, TName 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>>, {
+}>, TMetaData extends Record<string, any> = Record<string, any>> = ArvoContract<TUri, ReturnType<typeof ArvoOrchestratorEventTypeGen.init<TName>>, {
     [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'];
+            [K in ReturnType<typeof ArvoOrchestratorEventTypeGen.complete<TName>>]: TVersions[V]['complete'];
         };
     };
+}, TMetaData & {
+    contractType: 'ArvoOrchestratorContract';
+    rootType: TName;
+    initEventType: ReturnType<typeof ArvoOrchestratorEventTypeGen.init<TName>>;
+    completeEventType: ReturnType<typeof ArvoOrchestratorEventTypeGen.complete<TName>>;
 }>;
 /**
  * Interface defining the configuration structure for creating an Arvo Orchestrator Contract.
@@ -51,28 +46,26 @@ export type ArvoOrchestratorContract<TUri extends string = string, TType extends
  * @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 TMetaData - The metadata of the contract
  *
  * @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
+ * @property metadata - The optional contract metadata
+ * @property description - The optional contract description
  *
  * @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, TType extends string, TVersions extends Record<ArvoSemanticVersion, {
+export interface ICreateArvoOrchestratorContract<TUri extends string, TName extends string, TVersions extends Record<ArvoSemanticVersion, {
     init: z.ZodTypeAny;
     complete: z.ZodTypeAny;
-}>> {
-    /** Unique identifier URI for the contract */
+}>, TMetaData extends Record<string, any>> {
     uri: TUri;
-    /** Base event type used for generating init/complete event types */
-    type: TType;
-    /**
-     * Version-specific schemas for initialization and completion events
-     * @remarks Each version must provide both init and complete schemas
-     */
+    name: TName;
     versions: TVersions;
+    metadata?: TMetaData;
+    description?: string;
 }

package/dist/index.d.ts

@@ -4,14 +4,14 @@ 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, ExecutionOpenTelemetryConfiguration } from './OpenTelemetry/types';
-import { validateURI, cleanString, compareSemanticVersions, parseSemanticVersion } from './utils';
+import { validateURI, cleanString, compareSemanticVersions, parseSemanticVersion, EventDataschemaUtil } from './utils';
 import ArvoContract from './ArvoContract';
-import { createArvoContract, createSimpleArvoContract } from './ArvoContract/helpers';
+import { createArvoContract } from './ArvoContract/helpers';
 import { ArvoContractValidators } from './ArvoContract/validators';
 import { ArvoContractRecord, IArvoContract, ResolveArvoContractRecord, ArvoContractJSONSchema } from './ArvoContract/types';
 import ArvoEventFactory from './ArvoEventFactory';
-import { createArvoEventFactory, parseEventDataSchema } from './ArvoEventFactory/helpers';
-import { ArvoErrorSchema, ArvoSemanticVersionSchema } from './schema';
+import { createArvoEventFactory } from './ArvoEventFactory/helpers';
+import { ArvoErrorSchema, ArvoSemanticVersionSchema, isValidArvoSemanticVersion } from './schema';
 import OpenInference from './OpenTelemetry/OpenInference';
 import ArvoExecution from './OpenTelemetry/ArvoExecution';
 import { ArvoExecutionSpanKind } from './OpenTelemetry/ArvoExecution/types';
@@ -21,11 +21,16 @@ import { ArvoOrchestrationSubjectContentSchema } from './ArvoOrchestrationSubjec
 import { ArvoOrchestrationSubjectContent } from './ArvoOrchestrationSubject/type';
 import ArvoEventHttp from './ArvoEventHttp';
 import { ArvoEventHttpConfig } from './ArvoEventHttp/types';
-import { InferArvoContract, InferArvoEvent, ArvoSemanticVersion, ArvoErrorType, InferVersionedArvoContract } from './types';
+import { InferArvoEvent, ArvoSemanticVersion, ArvoErrorType, InferVersionedArvoContract } from './types';
 import { createArvoOrchestratorContract } from './ArvoOrchestratorContract';
 import { ICreateArvoOrchestratorContract, ArvoOrchestratorContract } from './ArvoOrchestratorContract/types';
 import { ArvoOrchestratorEventTypeGen } from './ArvoOrchestratorContract/typegen';
 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>;
 /**
  * Collection of Zod schemas for validating various aspects of Arvo events.
  * @property {z.ZodObject} CloudEventContextSchema - Schema for core CloudEvent properties.
@@ -48,20 +53,20 @@ declare const ArvoEventSchema: {
     }, "strip", import("zod").ZodTypeAny, {
         type: string;
         id: string;
-        time: string;
         source: string;
         specversion: "1.0";
         subject: string;
         datacontenttype: string;
         dataschema: string | null;
+        time: string;
     }, {
         type: string;
         id: string;
-        time: string;
         source: string;
         specversion: string;
         subject: string;
         dataschema: string | null;
+        time: string;
         datacontenttype?: string | undefined;
     }>;
     CloudEventExtensionSchema: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnion<[import("zod").ZodString, import("zod").ZodBoolean, import("zod").ZodNumber, import("zod").ZodNull]>>;
@@ -100,4 +105,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, InferArvoContract, createArvoOrchestratorContract, ICreateArvoOrchestratorContract, ArvoOrchestratorEventTypeGen, ExecutionOpenTelemetryConfiguration, parseEventDataSchema, ArvoOrchestrationSubjectContentSchema, ArvoSemanticVersionSchema, ArvoErrorSchema, ArvoErrorType, compareSemanticVersions, parseSemanticVersion, createSimpleArvoContract, ArvoOrchestratorContract, VersionedArvoContract, InferVersionedArvoContract, };
+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, };

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.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;
+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");
@@ -20,21 +20,21 @@ Object.defineProperty(exports, "validateURI", { enumerable: true, get: function
 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; } });
+Object.defineProperty(exports, "EventDataschemaUtil", { enumerable: true, get: function () { return utils_1.EventDataschemaUtil; } });
 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 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, "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; } });
+Object.defineProperty(exports, "isValidArvoSemanticVersion", { enumerable: true, get: function () { return schema_2.isValidArvoSemanticVersion; } });
 var OpenInference_1 = __importDefault(require("./OpenTelemetry/OpenInference"));
 exports.OpenInference = OpenInference_1.default;
 var ArvoExecution_1 = __importDefault(require("./OpenTelemetry/ArvoExecution"));
@@ -54,6 +54,13 @@ Object.defineProperty(exports, "createArvoOrchestratorContract", { enumerable: t
 var typegen_1 = require("./ArvoOrchestratorContract/typegen");
 Object.defineProperty(exports, "ArvoOrchestratorEventTypeGen", { enumerable: true, get: function () { return typegen_1.ArvoOrchestratorEventTypeGen; } });
 var schema_4 = require("./ArvoOrchestratorContract/schema");
+var VersionedArvoContract_1 = require("./ArvoContract/VersionedArvoContract");
+Object.defineProperty(exports, "VersionedArvoContract", { enumerable: true, get: function () { return VersionedArvoContract_1.VersionedArvoContract; } });
+var WildCardArvoSemanticVersion_1 = require("./ArvoContract/WildCardArvoSemanticVersion");
+Object.defineProperty(exports, "isWildCardArvoSematicVersion", { enumerable: true, get: function () { return WildCardArvoSemanticVersion_1.isWildCardArvoSematicVersion; } });
+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; } });
 /**
  * Collection of Zod schemas for validating various aspects of Arvo events.
  * @property {z.ZodObject} CloudEventContextSchema - Schema for core CloudEvent properties.

package/dist/schema.d.ts

@@ -10,12 +10,13 @@ export declare const ArvoErrorSchema: z.ZodObject<{
     errorMessage: z.ZodString;
     errorStack: z.ZodNullable<z.ZodString>;
 }, "strip", z.ZodTypeAny, {
-    errorMessage: string;
     errorName: string;
+    errorMessage: string;
     errorStack: string | null;
 }, {
-    errorMessage: string;
     errorName: string;
+    errorMessage: string;
     errorStack: string | null;
 }>;
 export declare const ArvoSemanticVersionSchema: z.ZodString;
+export declare const isValidArvoSemanticVersion: (version: string) => boolean;

package/dist/schema.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ArvoSemanticVersionSchema = exports.ArvoErrorSchema = void 0;
+exports.isValidArvoSemanticVersion = exports.ArvoSemanticVersionSchema = exports.ArvoErrorSchema = void 0;
 var zod_1 = require("zod");
 /**
  * Schema for Arvo error objects.
@@ -18,3 +18,8 @@ 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');
+// Check is the provided version is a valid arvo semantic version
+var isValidArvoSemanticVersion = function (version) {
+    return exports.ArvoSemanticVersionSchema.safeParse(version).success;
+};
+exports.isValidArvoSemanticVersion = isValidArvoSemanticVersion;