arvo-core 1.2.3 → 2.0.1

package/dist/types.d.ts

@@ -2,18 +2,61 @@ import { z } from 'zod';
 import ArvoContract from './ArvoContract';
 import ArvoEvent from './ArvoEvent';
 import { ArvoExtension, OpenTelemetryExtension } from './ArvoEvent/types';
-import ArvoOrchestratorContract from './ArvoOrchestratorContract';
+import { ArvoErrorSchema } from './schema';
+/**
+ * Represents the version of Arvo components following Semantic Versioning (SemVer).
+ *
+ * @format MAJOR.MINOR.PATCH where each component is a non-negative integer
+ * @restriction Must not contain semicolons (;)
+ *
+ * @example
+ * ```typescript
+ * const version: ArvoSemanticVersion = "1.0.0";
+ * const preRelease: ArvoSemanticVersion = "0.5.2";
+ * const major: ArvoSemanticVersion = "2.0.0";
+ * ```
+ */
+export type ArvoSemanticVersion = `${number}.${number}.${number}`;
 /**
  * A type utility that infers the structure of an ArvoEvent.
  *
- * @template T - The type to infer from, expected to be an ArvoEvent.
+ * @template TData - The type of the event payload
+ * @template TExtension - Additional extension properties for the event
+ * @template TType - The literal type string identifying the event
  *
- * @returns An object type that includes all properties of an ArvoEvent,
- * including its data, extensions, and standard CloudEvents properties.
+ * @property id - Unique identifier for the event (UUID v4 recommended)
+ * @property source - Identifier for the context where the event occurred
+ * @property specversion - CloudEvents specification version
+ * @property type - Event type identifier
+ * @property subject - Event subject in the producer's context
+ * @property datacontenttype - MIME type of the event payload
+ * @property dataschema - URI reference to the event's JSON schema
+ * @property data - The actual event payload
+ * @property time - ISO 8601 timestamp of event occurrence
  *
  * @example
- * type MyEvent = InferArvoEvent<ArvoEvent<{ message: string }, { customField: number }, 'my.event.type'>>;
- * // MyEvent will have properties like id, source, data.message, customField, etc.
+ * ```typescript
+ * type UserCreatedEvent = InferArvoEvent<ArvoEvent<
+ *   { userId: string; email: string },
+ *   { region: string },
+ *   'user.created'
+ * >>;
+ *
+ * // Results in:
+ * // {
+ * //   id: string;
+ * //   source: string;
+ * //   specversion: string;
+ * //   type: 'user.created';
+ * //   subject: string;
+ * //   datacontenttype: string;
+ * //   dataschema: string | null;
+ * //   data: { userId: string; email: string };
+ * //   time: string;
+ * //   region: string;
+ * //   // ... plus ArvoExtension & OpenTelemetryExtension properties
+ * // }
+ * ```
  */
 export type InferArvoEvent<T> = T extends ArvoEvent<infer TData, infer TExtension, infer TType> ? {
     /** Unique identifier of the event */
@@ -35,92 +78,75 @@ export type InferArvoEvent<T> = T extends ArvoEvent<infer TData, infer TExtensio
     /** Timestamp of when the occurrence happened */
     time: string;
 } & ArvoExtension & OpenTelemetryExtension & TExtension : never;
-/**
- * Helper type to infer the TypeScript type from a Zod schema.
- *
- * @template T - The Zod schema type to infer from.
- *
- * @returns The TypeScript type that corresponds to the Zod schema.
- *
- * @example
- * const mySchema = z.object({ name: z.string(), age: z.number() });
- * type MyType = InferZodSchema<typeof mySchema>;
- * // MyType will be { name: string; age: number; }
- */
 type InferZodSchema<T> = T extends z.ZodTypeAny ? z.infer<T> : never;
 /**
- * A type utility that infers the structure of an ArvoContract.
+ * A comprehensive type utility that infers the complete structure of an ArvoContract,
+ * including versioned event types, accepted events, and emitted events.
  *
- * @template T - The type to infer from, expected to be an ArvoContract.
+ * @template T - The ArvoContract type to infer from
  *
- * @returns An object type that includes the URI, accepted event type, and emitted event types of the contract.
+ * @property uri - Unique identifier for the contract
+ * @property type - The event type this contract handles
+ * @property versions - Version-specific contract definitions
+ * @property versions[version].accepts - Events this contract version can handle
+ * @property versions[version].emits - Events this contract version can produce
+ * @property systemError - System error event definition for this contract
  *
  * @example
- * const myContract = new ArvoContract('my-uri', 'my-type', z.object({ input: z.string() }), {
- *   'output.event': z.object({ result: z.number() })
- * });
- * type MyContractType = InferArvoContract<typeof myContract>;
- * // MyContractType will have properties uri, accepts, and emits
- */
-export type InferArvoContract<T extends ArvoContract<string, string, z.ZodTypeAny, Record<string, z.ZodTypeAny>>> = T extends ArvoContract<infer TUri, infer TType, infer TAcceptSchema, infer TEmits> ? {
-    /** The URI of the contract */
-    uri: TUri;
-    /** The event type that this contract accepts */
-    accepts: InferArvoEvent<ArvoEvent<InferZodSchema<TAcceptSchema>, {}, TType>>;
-    /** The event types that this contract can emit */
-    emits: {
-        [K in keyof TEmits]: InferArvoEvent<ArvoEvent<InferZodSchema<TEmits[K]>, {}, K & string>>;
-    };
-    /** The system error event type for this contract */
-    systemError: InferArvoEvent<ArvoEvent<InferZodSchema<T['systemError']['schema']>, {}, T['systemError']['type']>>;
-    /** Union type of all emittable events, including regular events and system error */
-    emittableEvents: ({
-        [K in keyof TEmits]: InferArvoEvent<ArvoEvent<InferZodSchema<TEmits[K]>, {}, K & string>>;
-    } & {
-        [K in `sys.${TType}.error`]: InferArvoEvent<ArvoEvent<InferZodSchema<T['systemError']['schema']>, {}, T['systemError']['type']>>;
-    })[keyof TEmits | `sys.${TType}.error`];
-} : never;
-/**
- * A type utility that infers the structure of an ArvoOrchestratorContract.
- *
- * @template T - The type to infer from, expected to be an ArvoOrchestratorContract.
+ * ```typescript
+ * const userContract = new ArvoContract(
+ *   'user-service',
+ *   'user.operation',
+ *   {
+ *     '1.0.0': {
+ *       accepts: z.object({ userId: z.string() }),
+ *       emits: {
+ *         'user.created': z.object({ userId: z.string(), timestamp: z.string() }),
+ *         'user.failed': z.object({ error: z.string() })
+ *       }
+ *     }
+ *   }
+ * );
  *
- * @returns An object type that includes the URI, accepted event type (init),
- * emitted event type (complete), system error event type, and other properties
- * of the orchestrator contract.
+ * type UserContractType = InferArvoContract<typeof userContract>;
+ * // Results in:
+ * // {
+ * //   uri: 'user-service';
+ * //   type: 'user.operation';
+ * //   versions: {
+ * //     '1.0.0': {
+ * //       accepts: { ... inferred input event type ... };
+ * //       emits: {
+ * //         'user.created': { ... inferred output event type ... };
+ * //         'user.failed': { ... inferred error event type ... };
+ * //       }
+ * //     }
+ * //   };
+ * //   systemError: { ... inferred system error event type ... };
+ * // }
+ * ```
  *
- * @example
- * const myOrchestratorContract = new ArvoOrchestratorContract({
- *   uri: 'my-orchestrator',
- *   init: { type: 'init', schema: z.object({ input: z.string() }) },
- *   complete: { type: 'complete', schema: z.object({ result: z.number() }) }
- * });
- * type MyOrchestratorContractType = InferArvoOrchestratorContract<typeof myOrchestratorContract>;
- * // MyOrchestratorContractType will have properties uri, accepts, emits, systemError, etc.
+ * @remarks
+ * - All version keys must be valid {@link ArvoSemanticVersion} strings
+ * - The contract must define at least one version
+ * - Each version must specify both accepted and emitted event schemas
+ * - System error handling is automatically included for all contracts
  */
-export type InferArvoOrchestratorContract<T extends ArvoOrchestratorContract<string, string, z.ZodTypeAny, string, z.ZodTypeAny>> = T extends ArvoOrchestratorContract<infer TUri, infer TInitType, infer TInit, infer TCompleteType, infer TComplete> ? {
-    /** The URI of the orchestrator contract */
+export type InferArvoContract<T extends ArvoContract<string, string, Record<ArvoSemanticVersion, {
+    accepts: z.ZodTypeAny;
+    emits: Record<string, z.ZodTypeAny>;
+}>>> = T extends ArvoContract<infer TUri, infer TType, infer TVersion> ? {
     uri: TUri;
-    /** The event type that this orchestrator contract accepts to initiate the process */
-    accepts: InferArvoEvent<ArvoEvent<InferZodSchema<TInit>, {}, TInitType>>;
-    /** The event type that this orchestrator contract emits upon completion */
-    emits: {
-        [K in TCompleteType]: InferArvoEvent<ArvoEvent<InferZodSchema<TComplete>, {}, K>>;
+    type: TType;
+    versions: {
+        [V in ArvoSemanticVersion & keyof TVersion]: {
+            accepts: InferArvoEvent<ArvoEvent<InferZodSchema<TVersion[V]['accepts']>, {}, TType>>;
+            emits: {
+                [K in keyof TVersion[V]['emits']]: InferArvoEvent<ArvoEvent<InferZodSchema<TVersion[V]['emits'][K]>, {}, K & string>>;
+            };
+        };
     };
-    /** The system error event type for this orchestrator contract */
     systemError: InferArvoEvent<ArvoEvent<InferZodSchema<T['systemError']['schema']>, {}, T['systemError']['type']>>;
-    /**
-     * Union type of all emittable events, including the completion event and system error.
-     * This can be used to represent all possible outcomes of the orchestration process.
-     */
-    emittableEvents: ({
-        [K in TCompleteType]: InferArvoEvent<ArvoEvent<InferZodSchema<TComplete>, {}, K>>;
-    } & {
-        [K in `sys.${TInitType}.error`]: InferArvoEvent<ArvoEvent<InferZodSchema<T['systemError']['schema']>, {}, T['systemError']['type']>>;
-    })[TCompleteType | `sys.${TInitType}.error`];
-    /** The initial event type and schema that starts the orchestration process */
-    init: InferArvoEvent<ArvoEvent<InferZodSchema<TInit>, {}, TInitType>>;
-    /** The completion event type and schema that signifies the end of the orchestration process */
-    complete: InferArvoEvent<ArvoEvent<InferZodSchema<TComplete>, {}, TCompleteType>>;
 } : never;
+export type ArvoErrorType = z.infer<typeof ArvoErrorSchema>;
 export {};

package/dist/utils.d.ts

@@ -1,3 +1,4 @@
+import { ArvoSemanticVersion } from './types';
 /**
  * Cleans a string by removing leading/trailing whitespace from each line,
  * removing empty lines, and joining the remaining lines with newline characters.
@@ -48,3 +49,23 @@ export declare const validateURI: (value: string) => boolean;
  * createTimestamp(-5);
  */
 export declare const createTimestamp: (offsetHours?: number) => string;
+/**
+ * Parse semantic version string into its numeric components
+ * @param version Semantic version string (e.g. "1.2.3")
+ * @returns Object containing major, minor, and patch numbers
+ */
+interface VersionComponents {
+    major: number;
+    minor: number;
+    patch: number;
+}
+export declare function parseSemanticVersion(version: ArvoSemanticVersion): VersionComponents;
+/**
+ * Compares two semantic versions according to semver rules
+ * Returns:
+ * - Positive number if version1 > version2
+ * - Negative number if version1 < version2
+ * - 0 if version1 === version2
+ */
+export declare function compareSemanticVersions(version1: ArvoSemanticVersion, version2: ArvoSemanticVersion): number;
+export {};

package/dist/utils.js

@@ -2,6 +2,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createTimestamp = exports.validateURI = void 0;
 exports.cleanString = cleanString;
+exports.parseSemanticVersion = parseSemanticVersion;
+exports.compareSemanticVersions = compareSemanticVersions;
 /**
  * Cleans a string by removing leading/trailing whitespace from each line,
  * removing empty lines, and joining the remaining lines with newline characters.
@@ -77,3 +79,34 @@ var createTimestamp = function (offsetHours) {
         : "-".concat(String(Math.abs(offsetHours)).padStart(2, '0'), ":00"));
 };
 exports.createTimestamp = createTimestamp;
+function parseSemanticVersion(version) {
+    var _a = version.split('.').map(function (part) {
+        var num = parseInt(part, 10);
+        if (isNaN(num)) {
+            throw new Error("Invalid version number in ".concat(version));
+        }
+        return num;
+    }), major = _a[0], minor = _a[1], patch = _a[2];
+    if (major === undefined || minor === undefined || patch === undefined) {
+        throw new Error("Invalid semantic version format: ".concat(version));
+    }
+    return { major: major, minor: minor, patch: patch };
+}
+/**
+ * Compares two semantic versions according to semver rules
+ * Returns:
+ * - Positive number if version1 > version2
+ * - Negative number if version1 < version2
+ * - 0 if version1 === version2
+ */
+function compareSemanticVersions(version1, version2) {
+    var v1 = parseSemanticVersion(version1);
+    var v2 = parseSemanticVersion(version2);
+    if (v1.major !== v2.major) {
+        return v1.major - v2.major;
+    }
+    if (v1.minor !== v2.minor) {
+        return v1.minor - v2.minor;
+    }
+    return v1.patch - v2.patch;
+}

package/package.json

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

package/dist/ArvoContractLibrary/helpers.d.ts

@@ -1,10 +0,0 @@
-import ArvoContractLibrary from '.';
-import ArvoContract from '../ArvoContract';
-/**
- * Creates a new ArvoContractLibrary instance with the given ArvoContract instances.
- *
- * @template T - The type of ArvoContract to be stored in the library.
- * @param {...T[]} args - One or more ArvoContract instances to initialize the library.
- * @returns {ArvoContractLibrary<T>} A new ArvoContractLibrary instance containing the provided contracts.
- */
-export declare const createArvoContractLibrary: <T extends ArvoContract>(...args: T[]) => ArvoContractLibrary<T>;

package/dist/ArvoContractLibrary/helpers.js

@@ -1,22 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createArvoContractLibrary = void 0;
-var _1 = __importDefault(require("."));
-/**
- * Creates a new ArvoContractLibrary instance with the given ArvoContract instances.
- *
- * @template T - The type of ArvoContract to be stored in the library.
- * @param {...T[]} args - One or more ArvoContract instances to initialize the library.
- * @returns {ArvoContractLibrary<T>} A new ArvoContractLibrary instance containing the provided contracts.
- */
-var createArvoContractLibrary = function () {
-    var args = [];
-    for (var _i = 0; _i < arguments.length; _i++) {
-        args[_i] = arguments[_i];
-    }
-    return new _1.default(args);
-};
-exports.createArvoContractLibrary = createArvoContractLibrary;

package/dist/ArvoContractLibrary/index.d.ts

@@ -1,61 +0,0 @@
-import ArvoContract from '../ArvoContract';
-/**
- * Extracts the URI type from a given ArvoContract type.
- * @template T - The ArvoContract type to extract from.
- */
-type ExtractContractUri<T> = T extends {
-    uri: infer U;
-} ? U : never;
-/**
- * A library class for managing and accessing ArvoContract instances.
- * @template T - The type of ArvoContract stored in the library.
- */
-export default class ArvoContractLibrary<T extends ArvoContract> {
-    /**
-     * The array of ArvoContract instances stored in the library.
-     * @private
-     * @readonly
-     */
-    private readonly _contracts;
-    /**
-     * Creates an instance of ArvoContractLibrary.
-     * @param {T[]} contracts - An array of ArvoContract instances to initialize the library.
-     * @throws An error in case the URI are duplicated
-     */
-    constructor(contracts: T[]);
-    /**
-     * Returns a readonly array of all ArvoContract instances in the library.
-     * @returns {Array<T>} A readonly array of ArvoContract instances.
-     */
-    list(): Array<T>;
-    /**
-     * Retrieves an ArvoContract instance by its URI.
-     * @template U - The type of the URI to search for.
-     * @param {U} uri - The URI of the contract to retrieve.
-     * @returns {Extract<T, { uri: U }>} A readonly ArvoContract instance matching the given URI.
-     * @throws {Error} If no contract with the given URI is found in the library.
-     */
-    get<U extends ExtractContractUri<T>>(uri: U): Extract<T, {
-        uri: U;
-    }>;
-    /**
-     * Get an object where keys are contract URIs and values are readonly contract instances.
-     */
-    get contracts(): {
-        [K in ExtractContractUri<T>]: Extract<T, {
-            uri: K;
-        }>;
-    };
-    /**
-     * Checks if the library contains a contract with the given URI.
-     * @param {string} uri - The URI to check for.
-     * @returns {boolean} True if a contract with the given URI exists in the library, false otherwise.
-     */
-    has(uri: string): boolean;
-    /**
-     * Returns the number of contracts in the library.
-     * @returns {number} The number of contracts in the library.
-     */
-    get size(): number;
-}
-export {};

package/dist/ArvoContractLibrary/index.js

@@ -1,87 +0,0 @@
-"use strict";
-var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
-    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
-        if (ar || !(i in from)) {
-            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
-            ar[i] = from[i];
-        }
-    }
-    return to.concat(ar || Array.prototype.slice.call(from));
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-/**
- * A library class for managing and accessing ArvoContract instances.
- * @template T - The type of ArvoContract stored in the library.
- */
-var ArvoContractLibrary = /** @class */ (function () {
-    /**
-     * Creates an instance of ArvoContractLibrary.
-     * @param {T[]} contracts - An array of ArvoContract instances to initialize the library.
-     * @throws An error in case the URI are duplicated
-     */
-    function ArvoContractLibrary(contracts) {
-        var uriSet = new Set();
-        contracts.forEach(function (contract) {
-            if (uriSet.has(contract.uri)) {
-                throw new Error("Duplicate contract URI found: ".concat(contract.uri));
-            }
-            uriSet.add(contract.uri);
-        });
-        this._contracts = __spreadArray([], contracts, true);
-    }
-    /**
-     * Returns a readonly array of all ArvoContract instances in the library.
-     * @returns {Array<T>} A readonly array of ArvoContract instances.
-     */
-    ArvoContractLibrary.prototype.list = function () {
-        return Object.freeze(__spreadArray([], this._contracts, true));
-    };
-    /**
-     * Retrieves an ArvoContract instance by its URI.
-     * @template U - The type of the URI to search for.
-     * @param {U} uri - The URI of the contract to retrieve.
-     * @returns {Extract<T, { uri: U }>} A readonly ArvoContract instance matching the given URI.
-     * @throws {Error} If no contract with the given URI is found in the library.
-     */
-    ArvoContractLibrary.prototype.get = function (uri) {
-        var contract = this._contracts.find(function (item) { return item.uri === uri; });
-        if (!contract) {
-            throw new Error("ArvoContract with URI \"".concat(uri, "\" not found in the library"));
-        }
-        return Object.freeze(contract);
-    };
-    Object.defineProperty(ArvoContractLibrary.prototype, "contracts", {
-        /**
-         * Get an object where keys are contract URIs and values are readonly contract instances.
-         */
-        get: function () {
-            return Object.freeze(Object.assign.apply(Object, __spreadArray([{}], this._contracts.map(function (item) {
-                var _a;
-                return (_a = {}, _a[item.uri] = Object.freeze(item), _a);
-            }), false)));
-        },
-        enumerable: false,
-        configurable: true
-    });
-    /**
-     * Checks if the library contains a contract with the given URI.
-     * @param {string} uri - The URI to check for.
-     * @returns {boolean} True if a contract with the given URI exists in the library, false otherwise.
-     */
-    ArvoContractLibrary.prototype.has = function (uri) {
-        return this._contracts.some(function (contract) { return contract.uri === uri; });
-    };
-    Object.defineProperty(ArvoContractLibrary.prototype, "size", {
-        /**
-         * Returns the number of contracts in the library.
-         * @returns {number} The number of contracts in the library.
-         */
-        get: function () {
-            return this._contracts.length;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    return ArvoContractLibrary;
-}());
-exports.default = ArvoContractLibrary;

package/dist/ArvoOrchestratorContract/helpers.d.ts

@@ -1,67 +0,0 @@
-import { z } from 'zod';
-import { ICreateArvoOrchestratorContract } from './types';
-import ArvoOrchestratorContract from '.';
-/**
- * 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.
- *
- * Key features:
- * 1. Initialization: Defines the structure and validation for the initial event that starts the orchestration.
- *    The init schema is automatically intersected with OrchestrationInitEventBaseSchema.
- * 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.
- *
- * Base Schema:
- * The OrchestrationInitEventBaseSchema is automatically intersected with the user-provided init schema.
- * This base schema includes essential fields for orchestration, such as:
- * - parentSubject$$: Identifies the subject of the parent process or event in the ArvoEvent system.
- *
- * This contract serves as a crucial component in maintaining consistency and type safety
- * throughout the orchestration process, from initiation to completion.
- *
- * @param param - The configuration object for creating the contract.
- * @param param.uri - The URI for the contract.
- * @param param.name - The name of the contract (must be lowercase alphanumeric with dots).
- * @param param.schema - The schema object containing init and complete Zod schemas.
- * @param param.schema.init - The Zod schema for initialization (will be intersected with OrchestrationInitEventBaseSchema).
- * @param param.schema.complete - The Zod schema for completion.
- *
- * @throws {Error} Throws an error if the name is not lowercase alphanumeric with dots.
- *
- * @returns Returns a new ArvoOrchestratorContract instance with the specified parameters.
- *
- * @example
- * ```typescript
- * import { createArvoOrchestratorContract } from 'arvo-core'
- * import { z } from 'zod'
- *
- * const contract = createArvoOrchestratorContract({
- *   uri: '#/example/contract',
- *   name: 'rag.orchestrator',
- *   schema: {
- *     init: z.object({
- *       request: z.string(),
- *       vectorStore: z.string(),
- *       llm: z.string()
- *     }),
- *     complete: z.object({
- *       response: z.string()
- *     })
- *   }
- * })
- * ```
- *
- * In this example, the actual init schema will be an intersection of the provided schema
- * and the OrchestrationInitEventBaseSchema, ensuring all necessary fields are included.
- */
-export declare const createArvoOrchestratorContract: <TUri extends string, TName extends string, TInit extends z.AnyZodObject, TComplete extends z.ZodTypeAny>(param: ICreateArvoOrchestratorContract<TUri, TName, TInit, TComplete>) => ArvoOrchestratorContract<TUri, `arvo.orc.${TName}`, z.ZodObject<z.objectUtil.extendShape<{
-    parentSubject$$: z.ZodNullable<z.ZodString>;
-}, TInit["shape"]>, TInit["_def"]["unknownKeys"], TInit["_def"]["catchall"], z.objectOutputType<z.objectUtil.extendShape<{
-    parentSubject$$: z.ZodNullable<z.ZodString>;
-}, TInit["shape"]>, TInit["_def"]["catchall"], TInit["_def"]["unknownKeys"]>, z.objectInputType<z.objectUtil.extendShape<{
-    parentSubject$$: z.ZodNullable<z.ZodString>;
-}, TInit["shape"]>, TInit["_def"]["catchall"], TInit["_def"]["unknownKeys"]>>, `arvo.orc.${TName}.done`, TComplete>;

package/dist/ArvoOrchestratorContract/helpers.js

@@ -1,101 +0,0 @@
-"use strict";
-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 _1 = __importDefault(require("."));
-var typegen_1 = require("./typegen");
-var schema_1 = require("./schema");
-/**
- * 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);
-}
-/**
- * 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.
- *
- * Key features:
- * 1. Initialization: Defines the structure and validation for the initial event that starts the orchestration.
- *    The init schema is automatically intersected with OrchestrationInitEventBaseSchema.
- * 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.
- *
- * Base Schema:
- * The OrchestrationInitEventBaseSchema is automatically intersected with the user-provided init schema.
- * This base schema includes essential fields for orchestration, such as:
- * - parentSubject$$: Identifies the subject of the parent process or event in the ArvoEvent system.
- *
- * This contract serves as a crucial component in maintaining consistency and type safety
- * throughout the orchestration process, from initiation to completion.
- *
- * @param param - The configuration object for creating the contract.
- * @param param.uri - The URI for the contract.
- * @param param.name - The name of the contract (must be lowercase alphanumeric with dots).
- * @param param.schema - The schema object containing init and complete Zod schemas.
- * @param param.schema.init - The Zod schema for initialization (will be intersected with OrchestrationInitEventBaseSchema).
- * @param param.schema.complete - The Zod schema for completion.
- *
- * @throws {Error} Throws an error if the name is not lowercase alphanumeric with dots.
- *
- * @returns Returns a new ArvoOrchestratorContract instance with the specified parameters.
- *
- * @example
- * ```typescript
- * import { createArvoOrchestratorContract } from 'arvo-core'
- * import { z } from 'zod'
- *
- * const contract = createArvoOrchestratorContract({
- *   uri: '#/example/contract',
- *   name: 'rag.orchestrator',
- *   schema: {
- *     init: z.object({
- *       request: z.string(),
- *       vectorStore: z.string(),
- *       llm: z.string()
- *     }),
- *     complete: z.object({
- *       response: z.string()
- *     })
- *   }
- * })
- * ```
- *
- * In this example, the actual init schema will be an intersection of the provided schema
- * and the OrchestrationInitEventBaseSchema, ensuring all necessary fields are included.
- */
-var createArvoOrchestratorContract = function (param) {
-    if (!isLowerAlphanumeric(param.name)) {
-        throw new Error("Invalid 'name' = '".concat(param.name, "'. The 'name' must only contain alphanumeric characters. e.g. test.orchestrator"));
-    }
-    var mergedSchema = schema_1.OrchestrationInitEventBaseSchema.merge(param.schema.init);
-    return new _1.default({
-        uri: param.uri,
-        init: {
-            type: typegen_1.ArvoOrchestratorEventTypeGen.init(param.name),
-            schema: mergedSchema,
-        },
-        complete: {
-            type: typegen_1.ArvoOrchestratorEventTypeGen.complete(param.name),
-            schema: param.schema.complete,
-        },
-    });
-};
-exports.createArvoOrchestratorContract = createArvoOrchestratorContract;