arvo-core 1.0.5 → 1.0.7

package/CHANGELOG.md

@@ -20,3 +20,11 @@
 
 - Updated README documentation
 
+## [1.0.6] - 2024-09-01
+
+- Updated ArvoContract typing mechanism
+
+## [1.0.7] - 2024-09-01
+
+- Updates to OpenTelemetry functions
+

package/dist/ArvoContract/helpers.d.ts

@@ -1,5 +1,5 @@
 import { IArvoContract } from './types';
-import ArvoContract, { ExtractEventType } from '.';
+import ArvoContract from '.';
 import { CreateArvoEvent } from '../ArvoEvent/types';
 import { TelemetryContext } from '../OpenTelemetry/types';
 import { ArvoContractRecord } from './types';
@@ -41,12 +41,12 @@ export declare const createArvoContract: <const TContract extends IArvoContract>
  * Creates a contractual ArvoEvent factory based on the provided contract.
  *
  * @template T - The type of the contract.
- * @template TAccepts - The type of events the contract accepts.
- * @template TEmits - The type of events the contract emits.
+ * @template TAccepts - The type of record the contract bound handler accepts, defaults to ArvoContractRecord.
+ * @template TEmits - The type of records the contract bound handler emits.
  * @param {ArvoContract<T, TAccepts, TEmits>} contract - The ArvoContract to base the events on.
  * @returns {Object} An object with 'accepts' and 'emits' methods for creating events.
  */
-export declare const createContractualArvoEvent: <T extends string = string, TAccepts extends ArvoContractRecord = ArvoContractRecord, TEmits extends ArvoContractRecord = ArvoContractRecord>(contract: ArvoContract<T, TAccepts, TEmits>) => {
+export declare const contractualArvoEventFactory: <T extends string = string, TAccepts extends ArvoContractRecord = ArvoContractRecord, TEmits extends Record<string, z.ZodTypeAny> = Record<string, z.ZodTypeAny>>(contract: ArvoContract<T, TAccepts, TEmits>) => {
     /**
      * Creates an ArvoEvent as per the accept record of the contract.
      *
@@ -69,9 +69,7 @@ export declare const createContractualArvoEvent: <T extends string = string, TAc
      * @returns The created ArvoEvent as per one of the emits records of the contract.
      * @throws {Error} If the event data fails validation against the contract.
      */
-    emits: <U extends ExtractEventType<TEmits>, TExtension extends Record<string, any>>(event: CreateArvoEvent<z.infer<Extract<TEmits, {
-        type: U;
-    }>["schema"]>, U>, extensions?: TExtension, telemetry?: TelemetryContext) => import("..").ArvoEvent<z.TypeOf<Extract<TEmits, {
+    emits: <U extends keyof TEmits & string, TExtension extends Record<string, any>>(event: CreateArvoEvent<z.infer<TEmits[U]>, U>, extensions?: TExtension, telemetry?: TelemetryContext) => import("..").ArvoEvent<z.TypeOf<Extract<TEmits, {
         type: U;
     }>["schema"]>, TExtension, string>;
 };

package/dist/ArvoContract/helpers.js

@@ -14,7 +14,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createContractualArvoEvent = exports.createArvoContract = void 0;
+exports.contractualArvoEventFactory = exports.createArvoContract = void 0;
 var _1 = __importDefault(require("."));
 var helpers_1 = require("../ArvoEvent/helpers");
 var OpenTelemetry_1 = require("../OpenTelemetry");
@@ -54,12 +54,12 @@ exports.createArvoContract = createArvoContract;
  * Creates a contractual ArvoEvent factory based on the provided contract.
  *
  * @template T - The type of the contract.
- * @template TAccepts - The type of events the contract accepts.
- * @template TEmits - The type of events the contract emits.
+ * @template TAccepts - The type of record the contract bound handler accepts, defaults to ArvoContractRecord.
+ * @template TEmits - The type of records the contract bound handler emits.
  * @param {ArvoContract<T, TAccepts, TEmits>} contract - The ArvoContract to base the events on.
  * @returns {Object} An object with 'accepts' and 'emits' methods for creating events.
  */
-var createContractualArvoEvent = function (contract) { return ({
+var contractualArvoEventFactory = function (contract) { return ({
     /**
      * Creates an ArvoEvent as per the accept record of the contract.
      *
@@ -71,7 +71,7 @@ var createContractualArvoEvent = function (contract) { return ({
      * @throws {Error} If the event data fails validation against the contract.
      */
     accepts: function (event, extensions, telemetry) {
-        return (0, OpenTelemetry_1.createOtelSpan)(telemetry || 'ArvoEvent Creation Tracer', 'createArvoContractEvent.accepts', {}, function () {
+        return (0, OpenTelemetry_1.createOtelSpan)(telemetry || 'ArvoEvent Creation Tracer', 'contractualArvoEventFactory.accepts', {}, function () {
             var validationResult = contract.validateInput(event.type, event.data);
             if (!validationResult.success) {
                 throw new Error("Accept Event data validation failed: ".concat(validationResult.error.message));
@@ -91,7 +91,7 @@ var createContractualArvoEvent = function (contract) { return ({
      * @throws {Error} If the event data fails validation against the contract.
      */
     emits: function (event, extensions, telemetry) {
-        return (0, OpenTelemetry_1.createOtelSpan)(telemetry || 'ArvoEvent Creation Tracer', 'createArvoContractEvent.emits', {}, function () {
+        return (0, OpenTelemetry_1.createOtelSpan)(telemetry || 'ArvoEvent Creation Tracer', 'contractualArvoEventFactory.emits', {}, function () {
             var validationResult = contract.validateOutput(event.type, event.data);
             if (!validationResult.success) {
                 throw new Error("Emit Event data validation failed: ".concat(validationResult.error.message));
@@ -100,4 +100,4 @@ var createContractualArvoEvent = function (contract) { return ({
         });
     },
 }); };
-exports.createContractualArvoEvent = createContractualArvoEvent;
+exports.contractualArvoEventFactory = contractualArvoEventFactory;

package/dist/ArvoContract/index.d.ts

@@ -1,21 +1,16 @@
 import { z } from 'zod';
 import { ArvoContractRecord, IArvoContract } from './types';
-/**
- * Extracts the event type from a given type T.
- * @template T - The type to extract the event type from.
- */
-export type ExtractEventType<T> = T extends {
-    type: infer U;
-} ? U : never;
 /**
  * ArvoContract class represents a contract with defined input and output schemas.
  * It provides methods for validating inputs and outputs based on the contract's specifications.
+ * An event handler can be bound to it so the this contract may impose the types
+ * on inputs and outputs of it
  *
- * @template T - The URI type.
- * @template TAccepts - The accepted record type.
- * @template TEmits - The emitted record type.
+ * @template TUri - The URI type, defaults to string.
+ * @template TAccepts - The type of record the contract bound handler accepts, defaults to ArvoContractRecord.
+ * @template TEmits - The type of records the contract bound handler emits.
  */
-export default class ArvoContract<T extends string = string, TAccepts extends ArvoContractRecord = ArvoContractRecord, TEmits extends ArvoContractRecord = ArvoContractRecord> {
+export default class ArvoContract<TUri extends string = string, TAccepts extends ArvoContractRecord = ArvoContractRecord, TEmits extends Record<string, z.ZodTypeAny> = Record<string, z.ZodTypeAny>> {
     private readonly _uri;
     private readonly _accepts;
     private readonly _emits;
@@ -23,54 +18,47 @@ export default class ArvoContract<T extends string = string, TAccepts extends Ar
     readonly description: string | null;
     /**
      * Creates an instance of ArvoContract.
-     * @param {IArvoContract<T, TAccepts, TEmits>} params - The contract parameters.
+     * @param {IArvoContract<TUri, TAccepts, TEmits>} params - The contract parameters.
      */
-    constructor(params: IArvoContract<T, TAccepts, TEmits>);
+    constructor(params: IArvoContract<TUri, TAccepts, TEmits>);
     /**
      * Gets the URI of the contract.
      * @returns {T} The contract's URI.
      */
-    get uri(): T;
+    get uri(): TUri;
     /**
-     * Gets the accepted record type and schema.
+     * Gets the type and schema of the event that the contact
+     * bound handler listens to.
      * @returns {TAccepts} The frozen accepts object.
      */
     get accepts(): TAccepts;
     /**
-     * Gets all emitted event types and schemas as a readonly record.
-     * Use this when you need to access all emitted events at once.
-     * @returns {Record<ExtractEventType<TEmits>, TEmits>} A frozen record of all emitted events.
-     */
-    get emits(): Record<ExtractEventType<TEmits>, TEmits>;
-    /**
-     * Gets a specific emitted event type and schema.
-     * Use this when you need to access a single emitted event by its type.
-     * @template U - The type of the emit record to retrieve.
-     * @param {U} type - The type of the emit record.
-     * @returns {Extract<TEmits, { type: U }>} The emit record.
-     * @throws {Error} If the emit type is not found in the contract.
+     * Gets all event types and schemas that can be emitted by the
+     * contract bound handler.
+     *
+     * @returns {TEmits} A record of all emitted events.
      */
-    getEmit<U extends ExtractEventType<TEmits>>(type: U): Extract<TEmits, {
-        type: U;
-    }>;
+    get emits(): TEmits;
     /**
-     * Validates the input against the contract's accept schema.
+     * Validates the contract bound handler's input against the
+     * contract's accept schema.
      * @template U - The type of the input to validate.
-     * @param {TAccepts['type']} type - The type of the input.
-     * @param {U} input - The input to validate.
+     * @param {TAccepts['type']} type - The type of the input event.
+     * @param {U} input - The input data to validate.
      * @returns {z.SafeParseReturnType<U, z.infer<TAccepts['schema']>>} The validation result.
      * @throws {Error} If the accept type is not found in the contract.
      */
     validateInput<U>(type: TAccepts['type'], input: U): z.SafeParseReturnType<U, z.infer<TAccepts['schema']>>;
     /**
-     * Validates the output against the contract's emit schema.
+     * Validates the contract bound handler's output against the
+     * contract's emit schema.
      * @template U - The type of the output to validate.
-     * @param {U} type - The type of the output.
-     * @param {unknown} output - The output to validate.
+     * @param {U} type - The type of the output event.
+     * @param {unknown} output - The output data to validate.
      * @returns {z.SafeParseReturnType<unknown, z.infer<Extract<TEmits, { type: U }>['schema']>>} The validation result.
      * @throws {Error} If the emit type is not found in the contract.
      */
-    validateOutput<U extends ExtractEventType<TEmits>>(type: U, output: unknown): z.SafeParseReturnType<unknown, z.infer<Extract<TEmits, {
+    validateOutput<U extends keyof TEmits>(type: U, output: unknown): z.SafeParseReturnType<unknown, z.infer<Extract<TEmits, {
         type: U;
     }>['schema']>>;
     /**
@@ -82,8 +70,8 @@ export default class ArvoContract<T extends string = string, TAccepts extends Ar
     private validateAccepts;
     /**
      * Validates the emits records.
-     * @param {TEmits[]} emits - The emits records to validate.
-     * @returns {Array<TEmits>} The validated emits records.
+     * @param {TEmits} emits - The emits records to validate.
+     * @returns {TEmits} The validated emits records.
      * @private
      */
     private validateEmits;
@@ -91,9 +79,9 @@ export default class ArvoContract<T extends string = string, TAccepts extends Ar
      * Exports the ArvoContract instance as a plain object conforming to the IArvoContract interface.
      * This method can be used to serialize the contract or to create a new instance with the same parameters.
      *
-     * @returns {IArvoContract<T, TAccepts, TEmits>} An object representing the contract, including its URI, accepts, and emits properties.
+     * @returns {IArvoContract<TUri, TAccepts, TEmits>} An object representing the contract, including its URI, accepts, and emits properties.
      */
-    export(): IArvoContract<T, TAccepts, TEmits>;
+    export(): IArvoContract<TUri, TAccepts, TEmits>;
     /**
      * Converts the ArvoContract instance to a JSON Schema representation.
      * This method provides a way to represent the contract's structure and validation rules
@@ -106,7 +94,7 @@ export default class ArvoContract<T extends string = string, TAccepts extends Ar
      *   - emits: An array of objects, each containing an emitted event type and its JSON Schema representation
      */
     toJsonSchema(): {
-        uri: T;
+        uri: TUri;
         description: string | null;
         accepts: {
             type: string;

package/dist/ArvoContract/index.js

@@ -1,4 +1,15 @@
 "use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 var zod_1 = require("zod");
 var validators_1 = require("./validators");
@@ -6,15 +17,17 @@ var zod_to_json_schema_1 = require("zod-to-json-schema");
 /**
  * ArvoContract class represents a contract with defined input and output schemas.
  * It provides methods for validating inputs and outputs based on the contract's specifications.
+ * An event handler can be bound to it so the this contract may impose the types
+ * on inputs and outputs of it
  *
- * @template T - The URI type.
- * @template TAccepts - The accepted record type.
- * @template TEmits - The emitted record type.
+ * @template TUri - The URI type, defaults to string.
+ * @template TAccepts - The type of record the contract bound handler accepts, defaults to ArvoContractRecord.
+ * @template TEmits - The type of records the contract bound handler emits.
  */
 var ArvoContract = /** @class */ (function () {
     /**
      * Creates an instance of ArvoContract.
-     * @param {IArvoContract<T, TAccepts, TEmits>} params - The contract parameters.
+     * @param {IArvoContract<TUri, TAccepts, TEmits>} params - The contract parameters.
      */
     function ArvoContract(params) {
         this._uri = validators_1.ArvoContractValidators.contract.uri.parse(params.uri);
@@ -36,7 +49,8 @@ var ArvoContract = /** @class */ (function () {
     });
     Object.defineProperty(ArvoContract.prototype, "accepts", {
         /**
-         * Gets the accepted record type and schema.
+         * Gets the type and schema of the event that the contact
+         * bound handler listens to.
          * @returns {TAccepts} The frozen accepts object.
          */
         get: function () {
@@ -47,40 +61,23 @@ var ArvoContract = /** @class */ (function () {
     });
     Object.defineProperty(ArvoContract.prototype, "emits", {
         /**
-         * Gets all emitted event types and schemas as a readonly record.
-         * Use this when you need to access all emitted events at once.
-         * @returns {Record<ExtractEventType<TEmits>, TEmits>} A frozen record of all emitted events.
+         * Gets all event types and schemas that can be emitted by the
+         * contract bound handler.
+         *
+         * @returns {TEmits} A record of all emitted events.
          */
         get: function () {
-            return Object.freeze(this._emits.reduce(function (acc, emit) {
-                // @ts-ignore
-                acc[emit.type] = emit;
-                return acc;
-            }, {}));
+            return __assign({}, this._emits);
         },
         enumerable: false,
         configurable: true
     });
     /**
-     * Gets a specific emitted event type and schema.
-     * Use this when you need to access a single emitted event by its type.
-     * @template U - The type of the emit record to retrieve.
-     * @param {U} type - The type of the emit record.
-     * @returns {Extract<TEmits, { type: U }>} The emit record.
-     * @throws {Error} If the emit type is not found in the contract.
-     */
-    ArvoContract.prototype.getEmit = function (type) {
-        var emit = this._emits.find(function (item) { return item.type === type; });
-        if (!emit) {
-            throw new Error("Emit type \"".concat(type, "\" not found in contract"));
-        }
-        return Object.freeze(emit);
-    };
-    /**
-     * Validates the input against the contract's accept schema.
+     * Validates the contract bound handler's input against the
+     * contract's accept schema.
      * @template U - The type of the input to validate.
-     * @param {TAccepts['type']} type - The type of the input.
-     * @param {U} input - The input to validate.
+     * @param {TAccepts['type']} type - The type of the input event.
+     * @param {U} input - The input data to validate.
      * @returns {z.SafeParseReturnType<U, z.infer<TAccepts['schema']>>} The validation result.
      * @throws {Error} If the accept type is not found in the contract.
      */
@@ -91,19 +88,20 @@ var ArvoContract = /** @class */ (function () {
         return this._accepts.schema.safeParse(input);
     };
     /**
-     * Validates the output against the contract's emit schema.
+     * Validates the contract bound handler's output against the
+     * contract's emit schema.
      * @template U - The type of the output to validate.
-     * @param {U} type - The type of the output.
-     * @param {unknown} output - The output to validate.
+     * @param {U} type - The type of the output event.
+     * @param {unknown} output - The output data to validate.
      * @returns {z.SafeParseReturnType<unknown, z.infer<Extract<TEmits, { type: U }>['schema']>>} The validation result.
      * @throws {Error} If the emit type is not found in the contract.
      */
     ArvoContract.prototype.validateOutput = function (type, output) {
         var emit = this.emits[type];
         if (!emit) {
-            throw new Error("Emit type \"".concat(type, "\" not found in contract"));
+            throw new Error("Emit type \"".concat(type.toString(), "\" not found in contract"));
         }
-        return emit.schema.safeParse(output);
+        return emit.safeParse(output);
     };
     /**
      * Validates the accepts record.
@@ -119,21 +117,22 @@ var ArvoContract = /** @class */ (function () {
     };
     /**
      * Validates the emits records.
-     * @param {TEmits[]} emits - The emits records to validate.
-     * @returns {Array<TEmits>} The validated emits records.
+     * @param {TEmits} emits - The emits records to validate.
+     * @returns {TEmits} The validated emits records.
      * @private
      */
     ArvoContract.prototype.validateEmits = function (emits) {
-        return Object.freeze(emits.map(function (item) { return ({
-            type: validators_1.ArvoContractValidators.record.type.parse(item.type),
-            schema: item.schema,
-        }); }));
+        Object.entries(emits).forEach(function (_a) {
+            var key = _a[0];
+            return validators_1.ArvoContractValidators.record.type.parse(key);
+        });
+        return Object.freeze(emits);
     };
     /**
      * Exports the ArvoContract instance as a plain object conforming to the IArvoContract interface.
      * This method can be used to serialize the contract or to create a new instance with the same parameters.
      *
-     * @returns {IArvoContract<T, TAccepts, TEmits>} An object representing the contract, including its URI, accepts, and emits properties.
+     * @returns {IArvoContract<TUri, TAccepts, TEmits>} An object representing the contract, including its URI, accepts, and emits properties.
      */
     ArvoContract.prototype.export = function () {
         return {
@@ -143,10 +142,7 @@ var ArvoContract = /** @class */ (function () {
                 type: this._accepts.type,
                 schema: this._accepts.schema,
             },
-            emits: this._emits.map(function (emit) { return ({
-                type: emit.type,
-                schema: emit.schema,
-            }); }),
+            emits: __assign({}, this._emits),
         };
     };
     /**
@@ -168,10 +164,13 @@ var ArvoContract = /** @class */ (function () {
                 type: this._accepts.type,
                 schema: (0, zod_to_json_schema_1.zodToJsonSchema)(this._accepts.schema),
             },
-            emits: this._emits.map(function (item) { return ({
-                type: zod_1.z.literal(item.type),
-                schema: (0, zod_to_json_schema_1.zodToJsonSchema)(item.schema),
-            }); }),
+            emits: Object.entries(this._emits).map(function (_a) {
+                var key = _a[0], value = _a[1];
+                return ({
+                    type: zod_1.z.literal(key),
+                    schema: (0, zod_to_json_schema_1.zodToJsonSchema)(value),
+                });
+            }),
         };
     };
     return ArvoContract;

package/dist/ArvoContract/types.d.ts

@@ -13,16 +13,16 @@ export type ArvoContractRecord<TType extends string = string, TSchema extends z.
 /**
  * Interface for an Arvo contract.
  * @template TUri - The URI type, defaults to string.
- * @template TAccepts - The type of record the contract accepts, defaults to ArvoContractRecord.
- * @template TEmits - The type of record the contract emits, defaults to ArvoContractRecord.
+ * @template TAccepts - The type of record the contract bound handler accepts, defaults to ArvoContractRecord.
+ * @template TEmits - The type of records the contract bound handler emits.
  */
-export interface IArvoContract<TUri extends string = string, TAccepts extends ArvoContractRecord = ArvoContractRecord, TEmits extends ArvoContractRecord = ArvoContractRecord> {
+export interface IArvoContract<TUri extends string = string, TAccepts extends ArvoContractRecord = ArvoContractRecord, TEmits extends Record<string, z.ZodTypeAny> = Record<string, z.ZodTypeAny>> {
     /** The unique identifier for the contract */
     uri: TUri;
     /** The record type that the contract accepts */
     accepts: TAccepts;
     /** An array of record types that the contract can emit */
-    emits: TEmits[];
+    emits: TEmits;
     /** (Optional) The description of the contract or its handler */
     description?: string | null;
 }

package/dist/ArvoEvent/helpers.js

@@ -47,11 +47,11 @@ var uuid_1 = require("uuid");
  * );
  */
 var createArvoEvent = function (event, extensions, telemetry) {
-    return (0, OpenTelemetry_1.createOtelSpan)(telemetry || 'ArvoEvent Creation Tracer', 'createArvoEvent', {}, function (span) {
+    return (0, OpenTelemetry_1.createOtelSpan)(telemetry || 'ArvoEvent Creation Tracer', 'createArvoEvent', {}, function (telemetryContext) {
         if (event.datacontenttype &&
             event.datacontenttype !== schema_1.ArvoDataContentType) {
             var warning = (0, utils_1.cleanString)("\n        Warning! The provided datacontenttype(=".concat(event.datacontenttype, ")\n        is not ArvoEvent compatible (=").concat(schema_1.ArvoDataContentType, "). There may \n        be some limited functionality.\n      "));
-            (0, OpenTelemetry_1.logToSpan)(span, {
+            (0, OpenTelemetry_1.logToSpan)(telemetryContext.span, {
                 level: 'WARNING',
                 message: warning,
             });

package/dist/OpenTelemetry/index.d.ts

@@ -86,7 +86,7 @@ export declare const exceptionToSpan: (span: Span, level: TelemetryLogLevel, err
  *   '12345'
  * );
  */
-export declare const createOtelSpan: <TArgs extends unknown[], TReturn>(telemetryContext: TelemetryContext | string, spanName: string, spanOptions: SpanOptions | undefined, wrappedFunction: (currentSpan: Span, ...args: TArgs) => TReturn, thisArg?: ThisParameterType<typeof wrappedFunction>, ...args: TArgs) => TReturn;
+export declare const createOtelSpan: <TArgs extends unknown[], TReturn>(telemetryContext: TelemetryContext | string, spanName: string, spanOptions: SpanOptions | undefined, wrappedFunction: (telemetryContext: TelemetryContext, ...args: TArgs) => TReturn, thisArg?: ThisParameterType<typeof wrappedFunction>, ...args: TArgs) => TReturn;
 /**
  * A constant representing a null or not applicable value in OpenTelemetry context.
  */

package/dist/OpenTelemetry/index.js

@@ -148,13 +148,17 @@ var createOtelSpan = function (telemetryContext, spanName, spanOptions, wrappedF
         activeTracer = api_1.trace.getTracer(telemetryContext);
     }
     else {
-        activeContext = (0, exports.getTelemetryContext)(telemetryContext.context.traceparent);
+        activeContext = (0, exports.getTelemetryContext)(telemetryContext.carrier.traceparent);
         activeTracer = telemetryContext.tracer;
     }
     var newSpan = activeTracer.startSpan(spanName, spanOptions, activeContext);
     try {
         var result = api_1.context.with(api_1.trace.setSpan(activeContext, newSpan), function () {
-            return wrappedFunction.call.apply(wrappedFunction, __spreadArray([thisArg, newSpan], args, false));
+            return wrappedFunction.call.apply(wrappedFunction, __spreadArray([thisArg, {
+                    span: newSpan,
+                    tracer: activeTracer,
+                    carrier: (0, exports.getTelemetryCarrier)(newSpan, activeContext)
+                }], args, false));
         });
         newSpan.setStatus({
             code: api_1.SpanStatusCode.OK,

package/dist/OpenTelemetry/types.d.ts

@@ -36,5 +36,5 @@ export type TelemetryContext = {
     /**
      * The telemetry headers
      */
-    context: TelemetryCarrier;
+    carrier: TelemetryCarrier;
 };

package/dist/index.d.ts

@@ -6,7 +6,7 @@ import { exceptionToSpan, logToSpan, getTelemetryContext, getTelemetryCarrier, c
 import { TelemetryCarrier, TelemetryContext, TelemetryLogLevel } from './OpenTelemetry/types';
 import { validateURI, cleanString } from './utils';
 import ArvoContract from './ArvoContract';
-import { createArvoContract, InferArvoContract, createContractualArvoEvent } from './ArvoContract/helpers';
+import { createArvoContract, InferArvoContract, contractualArvoEventFactory } from './ArvoContract/helpers';
 import { ArvoContractValidators } from './ArvoContract/validators';
 import { ArvoContractRecord, IArvoContract, ResolveArvoContractRecord } from './ArvoContract/types';
 import ArvoContractLibrary from './ArvoContractLibrary';
@@ -77,4 +77,4 @@ declare const ArvoEventSchemas: {
         tracestate: string | null;
     }>;
 };
-export { ArvoEvent, createArvoEvent, ArvoDataContentType, ArvoEventData, CloudEventExtension, ArvoEventSchemas, CloudEventContext, ArvoExtension, OpenTelemetryExtension, CreateArvoEvent, exceptionToSpan, logToSpan, getTelemetryCarrier, getTelemetryContext, createOtelSpan, TelemetryCarrier, TelemetryContext, TelemetryLogLevel, OTelNull, validateURI, cleanString, ArvoContract, createArvoContract, ArvoContractValidators, ArvoContractRecord, InferArvoContract, IArvoContract, ResolveArvoContractRecord, ArvoContractLibrary, createArvoContractLibrary, createContractualArvoEvent, };
+export { ArvoEvent, createArvoEvent, ArvoDataContentType, ArvoEventData, CloudEventExtension, ArvoEventSchemas, CloudEventContext, ArvoExtension, OpenTelemetryExtension, CreateArvoEvent, exceptionToSpan, logToSpan, getTelemetryCarrier, getTelemetryContext, createOtelSpan, TelemetryCarrier, TelemetryContext, TelemetryLogLevel, OTelNull, validateURI, cleanString, ArvoContract, createArvoContract, ArvoContractValidators, ArvoContractRecord, InferArvoContract, IArvoContract, ResolveArvoContractRecord, ArvoContractLibrary, createArvoContractLibrary, contractualArvoEventFactory, };

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.createContractualArvoEvent = exports.createArvoContractLibrary = exports.ArvoContractLibrary = exports.ArvoContractValidators = exports.createArvoContract = exports.ArvoContract = exports.cleanString = exports.validateURI = exports.OTelNull = exports.createOtelSpan = exports.getTelemetryContext = exports.getTelemetryCarrier = exports.logToSpan = exports.exceptionToSpan = exports.ArvoEventSchemas = exports.ArvoDataContentType = exports.createArvoEvent = exports.ArvoEvent = void 0;
+exports.contractualArvoEventFactory = exports.createArvoContractLibrary = exports.ArvoContractLibrary = exports.ArvoContractValidators = exports.createArvoContract = exports.ArvoContract = exports.cleanString = exports.validateURI = exports.OTelNull = exports.createOtelSpan = exports.getTelemetryContext = exports.getTelemetryCarrier = exports.logToSpan = exports.exceptionToSpan = exports.ArvoEventSchemas = exports.ArvoDataContentType = exports.createArvoEvent = exports.ArvoEvent = void 0;
 var ArvoEvent_1 = __importDefault(require("./ArvoEvent"));
 exports.ArvoEvent = ArvoEvent_1.default;
 var schema_1 = require("./ArvoEvent/schema");
@@ -24,7 +24,7 @@ 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, "createContractualArvoEvent", { enumerable: true, get: function () { return helpers_2.createContractualArvoEvent; } });
+Object.defineProperty(exports, "contractualArvoEventFactory", { enumerable: true, get: function () { return helpers_2.contractualArvoEventFactory; } });
 var validators_1 = require("./ArvoContract/validators");
 Object.defineProperty(exports, "ArvoContractValidators", { enumerable: true, get: function () { return validators_1.ArvoContractValidators; } });
 var ArvoContractLibrary_1 = __importDefault(require("./ArvoContractLibrary"));

package/package.json

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