Class ArvoMachine<TId, TVersion, TSelfContract, TServiceContract, TLogic>

constructor

• new ArvoMachine<TId, TVersion, TSelfContract, TServiceContract, TLogic>(id, version, contracts, logic, requiresResourceLocking?): ArvoMachine<TId, TVersion, TSelfContract, TServiceContract, TLogic>

• Creates a new ArvoMachine instance.

  Type Parameters

  • TId extends string
  • TVersion extends `${number}.${number}.${number}`
  • TSelfContract extends VersionedArvoContract<ArvoOrchestratorContract, TVersion>
  • TServiceContract extends Record<string, VersionedArvoContract<ArvoContract<string, string, Record<`${number}.${number}.${number}`, {
        accepts: ZodTypeAny;
        emits: Record<string, ZodTypeAny>;
    }>, Record<string, any>>, `${number}.${number}.${number}`>>
  • TLogic extends AnyActorLogic

  Parameters

  • id: TId

    A unique identifier for the machine. This ID must be unique within the scope of an orchestrator and is used for routing and logging.
  • version: TVersion

    The semantic version of the machine. Must follow semver format and match the version specified in the contract.
  • contracts: {
        self: TSelfContract;
        services: TServiceContract;
    }

    Configuration object containing contract definitions

    • self: TSelfContract

      The contract defining this machine's interface and capabilities

    • services: TServiceContract

      Record of contracts for services this machine can interact with
  • logic: TLogic

    The XState actor logic that defines the machine's behavior, including states, transitions, and actions.
  • OptionalrequiresResourceLocking: boolean = true

    Optional flag indicating if the machine needs distributed locks. False when machine has no parallel states and executes sequentially. Defaults to true.

  Returns ArvoMachine<TId, TVersion, TSelfContract, TServiceContract, TLogic>

  Throws

  When contracts are invalid or incompatible with the specified version

Readonlycontracts

Readonlyid

Readonlylogic

ReadonlyrequiresResourceLocking

Readonlyversion

source

• get source(): TSelfContract["accepts"]["type"]

• Gets the event type that this machine accepts, as defined in its contract.

  Returns TSelfContract["accepts"]["type"]

validateInput

• validateInput(event):
      | {
          type: "VALID";
      }
      | {
          type: "CONTRACT_UNRESOLVED";
      }
      | {
          error: Error;
          type: "INVALID";
      }
      | {
          error: ZodError<any>;
          type: "INVALID_DATA";
      }

• Validates an event against the machine's contracts and data schemas. Performs validation for both self-contract events and service contract events.

  Parameters

  • event: ArvoEvent<Record<string, any>, Record<string,
        | null
        | string
        | number
        | boolean>, string>

    The event to validate

  Returns
      | {
          type: "VALID";
      }
      | {
          type: "CONTRACT_UNRESOLVED";
      }
      | {
          error: Error;
          type: "INVALID";
      }
      | {
          error: ZodError<any>;
          type: "INVALID_DATA";
      }

  A validation result object:

  • "VALID" - Event is valid and can be processed
  • "CONTRACT_UNRESOLVED" - No matching contract found for the event
  • "INVALID" - Event dataschema conflict with contract
  • "INVALID_DATA" - Event data conflicts with contract

  Example

  const result = machine.validateInput(event);
   if (result.type === "VALID") {
    // Process the event
  } else if (result.type === "INVALID") {
    console.error(result.error);
  } else {
    // Handle unresolved contract
  }
  Copy

  Remarks

  The validation process includes:

  • Finding a matching contract (self or service)
  • Validating dataschema URI and version if present
  • Validating event data against the contract schema